// Code generated by sidekick. DO NOT EDIT.
//
// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import Foundation
#if canImport(FoundationNetworking)
  import FoundationNetworking
#endif
import GoogleCloudLocation
import GoogleCloudWkt
import GoogleIAMV1
import GoogleLongRunning
import GoogleRpc
import GoogleCloudGax

/// BackupForGKE allows Kubernetes administrators to configure, execute, and
/// manage backup and restore operations for their GKE clusters.
///
/// @Snippet(path: "BackupForGKEQuickstart")
public class BackupForGKEClient: Clients.BackupForGKEProtocol {
  let inner: any Clients.BackupForGKEStub
  let pollingErrorPolicy: GoogleCloudGax.PollingErrorPolicy
  let pollingBackoffPolicy: GoogleCloudGax.BackoffPolicy

  /// Creates a new `BackupForGKEClient` instance.
  public init(_ options: GoogleCloudGax.ClientOptions = .init()) throws {
    var inner: any Clients.BackupForGKEStub = try Clients.BackupForGKETransport(options)
    inner = Clients.BackupForGKERetry(inner, options: options)
    if let logger = options.logger {
      inner = Clients.BackupForGKELogging(inner, logger: logger)
    }
    self.inner = inner
    self.pollingErrorPolicy = options.pollingErrorPolicy
    self.pollingBackoffPolicy = options.pollingBackoffPolicy
  }

  /// Creates a new BackupPlan in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateBackupPlan")
  public func createBackupPlan(
    request: CreateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createBackupPlan(request: request, options: options)
  }

  /// Creates a new BackupPlan in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateBackupPlan")
  public func createBackupPlan(
    withPolling: CreateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BackupPlan>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try BackupPlan(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.createBackupPlan(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupPlan>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists BackupPlans in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackupPlans")
  public func listBackupPlans(
    request: ListBackupPlansRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupPlansResponse {
    try await self.inner.listBackupPlans(request: request, options: options)
  }

  /// Lists BackupPlans in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackupPlans")
  public func listBackupPlans(
    byItem: ListBackupPlansRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BackupPlan, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupPlansResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listBackupPlans(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_GetBackupPlan")
  public func getBackupPlan(
    request: GetBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.BackupPlan {
    try await self.inner.getBackupPlan(request: request, options: options)
  }

  /// Update a BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateBackupPlan")
  public func updateBackupPlan(
    request: UpdateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateBackupPlan(request: request, options: options)
  }

  /// Update a BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateBackupPlan")
  public func updateBackupPlan(
    withPolling: UpdateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BackupPlan>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try BackupPlan(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.updateBackupPlan(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupPlan>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an existing BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteBackupPlan")
  public func deleteBackupPlan(
    request: DeleteBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteBackupPlan(request: request, options: options)
  }

  /// Deletes an existing BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteBackupPlan")
  public func deleteBackupPlan(
    withPolling: DeleteBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Void>.State
      in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response:
        return .init(done: true, result: .success(()))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.deleteBackupPlan(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Creates a new BackupChannel in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateBackupChannel")
  public func createBackupChannel(
    request: CreateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createBackupChannel(request: request, options: options)
  }

  /// Creates a new BackupChannel in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateBackupChannel")
  public func createBackupChannel(
    withPolling: CreateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BackupChannel>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try BackupChannel(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.createBackupChannel(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupChannel>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists BackupChannels in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackupChannels")
  public func listBackupChannels(
    request: ListBackupChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse {
    try await self.inner.listBackupChannels(request: request, options: options)
  }

  /// Lists BackupChannels in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackupChannels")
  public func listBackupChannels(
    byItem: ListBackupChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BackupChannel, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listBackupChannels(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single BackupChannel.
  ///
  /// @Snippet(path: "BackupForGKE_GetBackupChannel")
  public func getBackupChannel(
    request: GetBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.BackupChannel {
    try await self.inner.getBackupChannel(request: request, options: options)
  }

  /// Update a BackupChannel.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateBackupChannel")
  public func updateBackupChannel(
    request: UpdateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateBackupChannel(request: request, options: options)
  }

  /// Update a BackupChannel.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateBackupChannel")
  public func updateBackupChannel(
    withPolling: UpdateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BackupChannel>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try BackupChannel(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.updateBackupChannel(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupChannel>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an existing BackupChannel.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteBackupChannel")
  public func deleteBackupChannel(
    request: DeleteBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteBackupChannel(request: request, options: options)
  }

  /// Deletes an existing BackupChannel.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteBackupChannel")
  public func deleteBackupChannel(
    withPolling: DeleteBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Void>.State
      in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response:
        return .init(done: true, result: .success(()))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.deleteBackupChannel(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists BackupPlanBindings in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackupPlanBindings")
  public func listBackupPlanBindings(
    request: ListBackupPlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse {
    try await self.inner.listBackupPlanBindings(request: request, options: options)
  }

  /// Lists BackupPlanBindings in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackupPlanBindings")
  public func listBackupPlanBindings(
    byItem: ListBackupPlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listBackupPlanBindings(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single BackupPlanBinding.
  ///
  /// @Snippet(path: "BackupForGKE_GetBackupPlanBinding")
  public func getBackupPlanBinding(
    request: GetBackupPlanBindingRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.BackupPlanBinding {
    try await self.inner.getBackupPlanBinding(request: request, options: options)
  }

  /// Creates a Backup for the given BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_CreateBackup")
  public func createBackup(
    request: CreateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createBackup(request: request, options: options)
  }

  /// Creates a Backup for the given BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_CreateBackup")
  public func createBackup(
    withPolling: CreateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Backup> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Backup>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try Backup(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.createBackup(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Backup>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists the Backups for a given BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackups")
  public func listBackups(
    request: ListBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupsResponse {
    try await self.inner.listBackups(request: request, options: options)
  }

  /// Lists the Backups for a given BackupPlan.
  ///
  /// @Snippet(path: "BackupForGKE_ListBackups")
  public func listBackups(
    byItem: ListBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Backup, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listBackups(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single Backup.
  ///
  /// @Snippet(path: "BackupForGKE_GetBackup")
  public func getBackup(
    request: GetBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.Backup {
    try await self.inner.getBackup(request: request, options: options)
  }

  /// Update a Backup.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateBackup")
  public func updateBackup(
    request: UpdateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateBackup(request: request, options: options)
  }

  /// Update a Backup.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateBackup")
  public func updateBackup(
    withPolling: UpdateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Backup> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Backup>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try Backup(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.updateBackup(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Backup>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an existing Backup.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteBackup")
  public func deleteBackup(
    request: DeleteBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteBackup(request: request, options: options)
  }

  /// Deletes an existing Backup.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteBackup")
  public func deleteBackup(
    withPolling: DeleteBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Void>.State
      in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response:
        return .init(done: true, result: .success(()))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.deleteBackup(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists the VolumeBackups for a given Backup.
  ///
  /// @Snippet(path: "BackupForGKE_ListVolumeBackups")
  public func listVolumeBackups(
    request: ListVolumeBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse {
    try await self.inner.listVolumeBackups(request: request, options: options)
  }

  /// Lists the VolumeBackups for a given Backup.
  ///
  /// @Snippet(path: "BackupForGKE_ListVolumeBackups")
  public func listVolumeBackups(
    byItem: ListVolumeBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<VolumeBackup, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listVolumeBackups(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single VolumeBackup.
  ///
  /// @Snippet(path: "BackupForGKE_GetVolumeBackup")
  public func getVolumeBackup(
    request: GetVolumeBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.VolumeBackup {
    try await self.inner.getVolumeBackup(request: request, options: options)
  }

  /// Creates a new RestorePlan in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateRestorePlan")
  public func createRestorePlan(
    request: CreateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createRestorePlan(request: request, options: options)
  }

  /// Creates a new RestorePlan in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateRestorePlan")
  public func createRestorePlan(
    withPolling: CreateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<RestorePlan>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try RestorePlan(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.createRestorePlan(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestorePlan>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists RestorePlans in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestorePlans")
  public func listRestorePlans(
    request: ListRestorePlansRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestorePlansResponse {
    try await self.inner.listRestorePlans(request: request, options: options)
  }

  /// Lists RestorePlans in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestorePlans")
  public func listRestorePlans(
    byItem: ListRestorePlansRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RestorePlan, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestorePlansResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listRestorePlans(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_GetRestorePlan")
  public func getRestorePlan(
    request: GetRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.RestorePlan {
    try await self.inner.getRestorePlan(request: request, options: options)
  }

  /// Update a RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateRestorePlan")
  public func updateRestorePlan(
    request: UpdateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateRestorePlan(request: request, options: options)
  }

  /// Update a RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateRestorePlan")
  public func updateRestorePlan(
    withPolling: UpdateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<RestorePlan>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try RestorePlan(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.updateRestorePlan(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestorePlan>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an existing RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteRestorePlan")
  public func deleteRestorePlan(
    request: DeleteRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteRestorePlan(request: request, options: options)
  }

  /// Deletes an existing RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteRestorePlan")
  public func deleteRestorePlan(
    withPolling: DeleteRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Void>.State
      in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response:
        return .init(done: true, result: .success(()))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.deleteRestorePlan(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Creates a new RestoreChannel in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateRestoreChannel")
  public func createRestoreChannel(
    request: CreateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createRestoreChannel(request: request, options: options)
  }

  /// Creates a new RestoreChannel in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_CreateRestoreChannel")
  public func createRestoreChannel(
    withPolling: CreateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<RestoreChannel>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try RestoreChannel(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.createRestoreChannel(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestoreChannel>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists RestoreChannels in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestoreChannels")
  public func listRestoreChannels(
    request: ListRestoreChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse {
    try await self.inner.listRestoreChannels(request: request, options: options)
  }

  /// Lists RestoreChannels in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestoreChannels")
  public func listRestoreChannels(
    byItem: ListRestoreChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RestoreChannel, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listRestoreChannels(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single RestoreChannel.
  ///
  /// @Snippet(path: "BackupForGKE_GetRestoreChannel")
  public func getRestoreChannel(
    request: GetRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.RestoreChannel {
    try await self.inner.getRestoreChannel(request: request, options: options)
  }

  /// Update a RestoreChannel.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateRestoreChannel")
  public func updateRestoreChannel(
    request: UpdateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateRestoreChannel(request: request, options: options)
  }

  /// Update a RestoreChannel.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateRestoreChannel")
  public func updateRestoreChannel(
    withPolling: UpdateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<RestoreChannel>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try RestoreChannel(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.updateRestoreChannel(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestoreChannel>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an existing RestoreChannel.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteRestoreChannel")
  public func deleteRestoreChannel(
    request: DeleteRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteRestoreChannel(request: request, options: options)
  }

  /// Deletes an existing RestoreChannel.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteRestoreChannel")
  public func deleteRestoreChannel(
    withPolling: DeleteRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Void>.State
      in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response:
        return .init(done: true, result: .success(()))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.deleteRestoreChannel(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists RestorePlanBindings in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestorePlanBindings")
  public func listRestorePlanBindings(
    request: ListRestorePlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse {
    try await self.inner.listRestorePlanBindings(request: request, options: options)
  }

  /// Lists RestorePlanBindings in a given location.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestorePlanBindings")
  public func listRestorePlanBindings(
    byItem: ListRestorePlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse
      in
      var request = byItem
      request.pageToken = token
      return try await self.listRestorePlanBindings(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single RestorePlanBinding.
  ///
  /// @Snippet(path: "BackupForGKE_GetRestorePlanBinding")
  public func getRestorePlanBinding(
    request: GetRestorePlanBindingRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.RestorePlanBinding {
    try await self.inner.getRestorePlanBinding(request: request, options: options)
  }

  /// Creates a new Restore for the given RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_CreateRestore")
  public func createRestore(
    request: CreateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createRestore(request: request, options: options)
  }

  /// Creates a new Restore for the given RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_CreateRestore")
  public func createRestore(
    withPolling: CreateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Restore> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Restore>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try Restore(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.createRestore(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Restore>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists the Restores for a given RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestores")
  public func listRestores(
    request: ListRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestoresResponse {
    try await self.inner.listRestores(request: request, options: options)
  }

  /// Lists the Restores for a given RestorePlan.
  ///
  /// @Snippet(path: "BackupForGKE_ListRestores")
  public func listRestores(
    byItem: ListRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Restore, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestoresResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listRestores(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieves the details of a single Restore.
  ///
  /// @Snippet(path: "BackupForGKE_GetRestore")
  public func getRestore(
    request: GetRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.Restore {
    try await self.inner.getRestore(request: request, options: options)
  }

  /// Update a Restore.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateRestore")
  public func updateRestore(
    request: UpdateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateRestore(request: request, options: options)
  }

  /// Update a Restore.
  ///
  /// @Snippet(path: "BackupForGKE_UpdateRestore")
  public func updateRestore(
    withPolling: UpdateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Restore> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Restore>.State in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response(let anyValue):
        guard let anyValueUnwrapped = anyValue else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding(
                "Operation completed but response value was missing")))
        }
        let response = try Restore(fromAny: anyValueUnwrapped)
        return .init(done: true, result: .success(response))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.updateRestore(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Restore>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an existing Restore.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteRestore")
  public func deleteRestore(
    request: DeleteRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteRestore(request: request, options: options)
  }

  /// Deletes an existing Restore.
  ///
  /// @Snippet(path: "BackupForGKE_DeleteRestore")
  public func deleteRestore(
    withPolling: DeleteRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Void>.State
      in
      guard op.done else {
        return .init(done: false, result: nil)
      }

      switch op.result {
      case .response:
        return .init(done: true, result: .success(()))
      case .error(let status):
        guard let statusUnwrapped = status else {
          return .init(
            done: true,
            result: .failure(
              GoogleCloudGax.RequestError.binding("Operation completed but error value was missing")
            ))
        }
        let error = GoogleCloudGax.RequestError.service(
          GoogleCloudGax.ServiceError(
            code: GoogleRpc.Code(intValue: Int(statusUnwrapped.code)),
            message: statusUnwrapped.message))
        return .init(done: true, result: .failure(error))
      case .none:
        return .init(
          done: true,
          result: .failure(
            GoogleCloudGax.RequestError.binding("Operation completed but result was missing")))
      }
    }
    let rawOp = try await self.deleteRestore(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists the VolumeRestores for a given Restore.
  ///
  /// @Snippet(path: "BackupForGKE_ListVolumeRestores")
  public func listVolumeRestores(
    request: ListVolumeRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse {
    try await self.inner.listVolumeRestores(request: request, options: options)
  }

  /// Lists the VolumeRestores for a given Restore.
  ///
  /// @Snippet(path: "BackupForGKE_ListVolumeRestores")
  public func listVolumeRestores(
    byItem: ListVolumeRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<VolumeRestore, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listVolumeRestores(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Retrieve the details of a single VolumeRestore.
  ///
  /// @Snippet(path: "BackupForGKE_GetVolumeRestore")
  public func getVolumeRestore(
    request: GetVolumeRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.VolumeRestore {
    try await self.inner.getVolumeRestore(request: request, options: options)
  }

  /// Retrieve the link to the backupIndex.
  ///
  /// @Snippet(path: "BackupForGKE_GetBackupIndexDownloadUrl")
  public func getBackupIndexDownloadUrl(
    request: GetBackupIndexDownloadUrlRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse {
    try await self.inner.getBackupIndexDownloadUrl(request: request, options: options)
  }

  /// Lists information about the supported locations for this service.
  ///
  /// @Snippet(path: "BackupForGKE_ListLocations")
  public func listLocations(
    request: GoogleCloudLocation.ListLocationsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudLocation.ListLocationsResponse {
    try await self.inner.listLocations(request: request, options: options)
  }

  /// Lists information about the supported locations for this service.
  ///
  /// @Snippet(path: "BackupForGKE_ListLocations")
  public func listLocations(
    byItem: GoogleCloudLocation.ListLocationsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<GoogleCloudLocation.Location, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudLocation.ListLocationsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listLocations(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets information about a location.
  ///
  /// @Snippet(path: "BackupForGKE_GetLocation")
  public func getLocation(
    request: GoogleCloudLocation.GetLocationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudLocation.Location {
    try await self.inner.getLocation(request: request, options: options)
  }

  /// Sets the access control policy on the specified resource. Replaces
  /// any existing policy.
  ///
  /// Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED`
  /// errors.
  ///
  /// @Snippet(path: "BackupForGKE_SetIamPolicy")
  public func setIamPolicy(
    request: GoogleIAMV1.SetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.Policy {
    try await self.inner.setIamPolicy(request: request, options: options)
  }

  /// Gets the access control policy for a resource. Returns an empty policy
  /// if the resource exists and does not have a policy set.
  ///
  /// @Snippet(path: "BackupForGKE_GetIamPolicy")
  public func getIamPolicy(
    request: GoogleIAMV1.GetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.Policy {
    try await self.inner.getIamPolicy(request: request, options: options)
  }

  /// Returns permissions that a caller has on the specified resource. If the
  /// resource does not exist, this will return an empty set of
  /// permissions, not a `NOT_FOUND` error.
  ///
  /// Note: This operation is designed to be used for building
  /// permission-aware UIs and command-line tools, not for authorization
  /// checking. This operation may "fail open" without warning.
  ///
  /// @Snippet(path: "BackupForGKE_TestIamPermissions")
  public func testIamPermissions(
    request: GoogleIAMV1.TestIamPermissionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.TestIamPermissionsResponse {
    try await self.inner.testIamPermissions(request: request, options: options)
  }

  /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
  ///
  /// [google.longrunning.Operations]: https://www.google.com/search?q=Swift+google.longrunning+Operations
  ///
  /// @Snippet(path: "BackupForGKE_ListOperations")
  public func listOperations(
    request: GoogleLongRunning.ListOperationsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.ListOperationsResponse {
    try await self.inner.listOperations(request: request, options: options)
  }

  /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
  ///
  /// [google.longrunning.Operations]: https://www.google.com/search?q=Swift+google.longrunning+Operations
  ///
  /// @Snippet(path: "BackupForGKE_ListOperations")
  public func listOperations(
    byItem: GoogleLongRunning.ListOperationsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleLongRunning.ListOperationsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listOperations(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
  ///
  /// [google.longrunning.Operations]: https://www.google.com/search?q=Swift+google.longrunning+Operations
  ///
  /// @Snippet(path: "BackupForGKE_GetOperation")
  func getOperation(
    request: GoogleLongRunning.GetOperationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.getOperation(request: request, options: options)
  }

  /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
  ///
  /// [google.longrunning.Operations]: https://www.google.com/search?q=Swift+google.longrunning+Operations
  ///
  /// @Snippet(path: "BackupForGKE_DeleteOperation")
  public func deleteOperation(
    request: GoogleLongRunning.DeleteOperationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    try await self.inner.deleteOperation(request: request, options: options)
  }

  /// Provides the [Operations][google.longrunning.Operations] service functionality in this service.
  ///
  /// [google.longrunning.Operations]: https://www.google.com/search?q=Swift+google.longrunning+Operations
  ///
  /// @Snippet(path: "BackupForGKE_CancelOperation")
  public func cancelOperation(
    request: GoogleLongRunning.CancelOperationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    try await self.inner.cancelOperation(request: request, options: options)
  }
}

extension Clients {
  /// A Swift protocol to mock `BackupForGKEClient`.
  ///
  /// To mock `BackupForGKEClient` change your functions to receive
  /// `some BackupForGKEProtocol` or `any BackupForGKEProtocol`
  /// and pass a mock implementation in your tests.
  public protocol BackupForGKEProtocol {
    /// See `BackupForGKEClient.createBackupPlan`.
    func createBackupPlan(request: CreateBackupPlanRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createBackupPlan`.
    func createBackupPlan(withPolling: CreateBackupPlanRequest) async throws -> any GoogleCloudGax
      .PollableOperation<BackupPlan>

    /// See `BackupForGKEClient.createBackupPlan`.
    func createBackupPlan(
      parent: Swift.String,
      backupPlan: BackupPlan?,
      backupPlanId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan>

    /// See `BackupForGKEClient.listBackupPlans`.
    func listBackupPlans(request: ListBackupPlansRequest) async throws
      -> GoogleCloudGKEBackupV1.ListBackupPlansResponse

    /// See `BackupForGKEClient.listBackupPlans`.
    func listBackupPlans(
      byItem: ListBackupPlansRequest
    ) throws -> any AsyncSequence<BackupPlan, Swift.Error>

    /// See `BackupForGKEClient.listBackupPlans`.
    func listBackupPlans(
      parent: Swift.String,
    ) throws -> any AsyncSequence<BackupPlan, Swift.Error>

    /// See `BackupForGKEClient.getBackupPlan`.
    func getBackupPlan(request: GetBackupPlanRequest) async throws
      -> GoogleCloudGKEBackupV1.BackupPlan

    /// See `BackupForGKEClient.getBackupPlan`.
    func getBackupPlan(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.BackupPlan

    /// See `BackupForGKEClient.updateBackupPlan`.
    func updateBackupPlan(request: UpdateBackupPlanRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateBackupPlan`.
    func updateBackupPlan(withPolling: UpdateBackupPlanRequest) async throws -> any GoogleCloudGax
      .PollableOperation<BackupPlan>

    /// See `BackupForGKEClient.updateBackupPlan`.
    func updateBackupPlan(
      backupPlan: BackupPlan?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan>

    /// See `BackupForGKEClient.deleteBackupPlan`.
    func deleteBackupPlan(request: DeleteBackupPlanRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteBackupPlan`.
    func deleteBackupPlan(withPolling: DeleteBackupPlanRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

    /// See `BackupForGKEClient.deleteBackupPlan`.
    func deleteBackupPlan(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.createBackupChannel`.
    func createBackupChannel(request: CreateBackupChannelRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createBackupChannel`.
    func createBackupChannel(withPolling: CreateBackupChannelRequest) async throws
      -> any GoogleCloudGax.PollableOperation<BackupChannel>

    /// See `BackupForGKEClient.createBackupChannel`.
    func createBackupChannel(
      parent: Swift.String,
      backupChannel: BackupChannel?,
      backupChannelId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel>

    /// See `BackupForGKEClient.listBackupChannels`.
    func listBackupChannels(request: ListBackupChannelsRequest) async throws
      -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse

    /// See `BackupForGKEClient.listBackupChannels`.
    func listBackupChannels(
      byItem: ListBackupChannelsRequest
    ) throws -> any AsyncSequence<BackupChannel, Swift.Error>

    /// See `BackupForGKEClient.listBackupChannels`.
    func listBackupChannels(
      parent: Swift.String,
    ) throws -> any AsyncSequence<BackupChannel, Swift.Error>

    /// See `BackupForGKEClient.getBackupChannel`.
    func getBackupChannel(request: GetBackupChannelRequest) async throws
      -> GoogleCloudGKEBackupV1.BackupChannel

    /// See `BackupForGKEClient.getBackupChannel`.
    func getBackupChannel(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.BackupChannel

    /// See `BackupForGKEClient.updateBackupChannel`.
    func updateBackupChannel(request: UpdateBackupChannelRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateBackupChannel`.
    func updateBackupChannel(withPolling: UpdateBackupChannelRequest) async throws
      -> any GoogleCloudGax.PollableOperation<BackupChannel>

    /// See `BackupForGKEClient.updateBackupChannel`.
    func updateBackupChannel(
      backupChannel: BackupChannel?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel>

    /// See `BackupForGKEClient.deleteBackupChannel`.
    func deleteBackupChannel(request: DeleteBackupChannelRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteBackupChannel`.
    func deleteBackupChannel(withPolling: DeleteBackupChannelRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.deleteBackupChannel`.
    func deleteBackupChannel(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listBackupPlanBindings`.
    func listBackupPlanBindings(request: ListBackupPlanBindingsRequest) async throws
      -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse

    /// See `BackupForGKEClient.listBackupPlanBindings`.
    func listBackupPlanBindings(
      byItem: ListBackupPlanBindingsRequest
    ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error>

    /// See `BackupForGKEClient.listBackupPlanBindings`.
    func listBackupPlanBindings(
      parent: Swift.String,
    ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error>

    /// See `BackupForGKEClient.getBackupPlanBinding`.
    func getBackupPlanBinding(request: GetBackupPlanBindingRequest) async throws
      -> GoogleCloudGKEBackupV1.BackupPlanBinding

    /// See `BackupForGKEClient.getBackupPlanBinding`.
    func getBackupPlanBinding(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.BackupPlanBinding

    /// See `BackupForGKEClient.createBackup`.
    func createBackup(request: CreateBackupRequest) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createBackup`.
    func createBackup(withPolling: CreateBackupRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Backup>

    /// See `BackupForGKEClient.createBackup`.
    func createBackup(
      parent: Swift.String,
      backup: Backup?,
      backupId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Backup>

    /// See `BackupForGKEClient.listBackups`.
    func listBackups(request: ListBackupsRequest) async throws
      -> GoogleCloudGKEBackupV1.ListBackupsResponse

    /// See `BackupForGKEClient.listBackups`.
    func listBackups(
      byItem: ListBackupsRequest
    ) throws -> any AsyncSequence<Backup, Swift.Error>

    /// See `BackupForGKEClient.listBackups`.
    func listBackups(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Backup, Swift.Error>

    /// See `BackupForGKEClient.getBackup`.
    func getBackup(request: GetBackupRequest) async throws -> GoogleCloudGKEBackupV1.Backup

    /// See `BackupForGKEClient.getBackup`.
    func getBackup(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.Backup

    /// See `BackupForGKEClient.updateBackup`.
    func updateBackup(request: UpdateBackupRequest) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateBackup`.
    func updateBackup(withPolling: UpdateBackupRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Backup>

    /// See `BackupForGKEClient.updateBackup`.
    func updateBackup(
      backup: Backup?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Backup>

    /// See `BackupForGKEClient.deleteBackup`.
    func deleteBackup(request: DeleteBackupRequest) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteBackup`.
    func deleteBackup(withPolling: DeleteBackupRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

    /// See `BackupForGKEClient.deleteBackup`.
    func deleteBackup(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listVolumeBackups`.
    func listVolumeBackups(request: ListVolumeBackupsRequest) async throws
      -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse

    /// See `BackupForGKEClient.listVolumeBackups`.
    func listVolumeBackups(
      byItem: ListVolumeBackupsRequest
    ) throws -> any AsyncSequence<VolumeBackup, Swift.Error>

    /// See `BackupForGKEClient.listVolumeBackups`.
    func listVolumeBackups(
      parent: Swift.String,
    ) throws -> any AsyncSequence<VolumeBackup, Swift.Error>

    /// See `BackupForGKEClient.getVolumeBackup`.
    func getVolumeBackup(request: GetVolumeBackupRequest) async throws
      -> GoogleCloudGKEBackupV1.VolumeBackup

    /// See `BackupForGKEClient.getVolumeBackup`.
    func getVolumeBackup(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.VolumeBackup

    /// See `BackupForGKEClient.createRestorePlan`.
    func createRestorePlan(request: CreateRestorePlanRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createRestorePlan`.
    func createRestorePlan(withPolling: CreateRestorePlanRequest) async throws -> any GoogleCloudGax
      .PollableOperation<RestorePlan>

    /// See `BackupForGKEClient.createRestorePlan`.
    func createRestorePlan(
      parent: Swift.String,
      restorePlan: RestorePlan?,
      restorePlanId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan>

    /// See `BackupForGKEClient.listRestorePlans`.
    func listRestorePlans(request: ListRestorePlansRequest) async throws
      -> GoogleCloudGKEBackupV1.ListRestorePlansResponse

    /// See `BackupForGKEClient.listRestorePlans`.
    func listRestorePlans(
      byItem: ListRestorePlansRequest
    ) throws -> any AsyncSequence<RestorePlan, Swift.Error>

    /// See `BackupForGKEClient.listRestorePlans`.
    func listRestorePlans(
      parent: Swift.String,
    ) throws -> any AsyncSequence<RestorePlan, Swift.Error>

    /// See `BackupForGKEClient.getRestorePlan`.
    func getRestorePlan(request: GetRestorePlanRequest) async throws
      -> GoogleCloudGKEBackupV1.RestorePlan

    /// See `BackupForGKEClient.getRestorePlan`.
    func getRestorePlan(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.RestorePlan

    /// See `BackupForGKEClient.updateRestorePlan`.
    func updateRestorePlan(request: UpdateRestorePlanRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateRestorePlan`.
    func updateRestorePlan(withPolling: UpdateRestorePlanRequest) async throws -> any GoogleCloudGax
      .PollableOperation<RestorePlan>

    /// See `BackupForGKEClient.updateRestorePlan`.
    func updateRestorePlan(
      restorePlan: RestorePlan?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan>

    /// See `BackupForGKEClient.deleteRestorePlan`.
    func deleteRestorePlan(request: DeleteRestorePlanRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteRestorePlan`.
    func deleteRestorePlan(withPolling: DeleteRestorePlanRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

    /// See `BackupForGKEClient.deleteRestorePlan`.
    func deleteRestorePlan(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.createRestoreChannel`.
    func createRestoreChannel(request: CreateRestoreChannelRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createRestoreChannel`.
    func createRestoreChannel(withPolling: CreateRestoreChannelRequest) async throws
      -> any GoogleCloudGax.PollableOperation<RestoreChannel>

    /// See `BackupForGKEClient.createRestoreChannel`.
    func createRestoreChannel(
      parent: Swift.String,
      restoreChannel: RestoreChannel?,
      restoreChannelId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel>

    /// See `BackupForGKEClient.listRestoreChannels`.
    func listRestoreChannels(request: ListRestoreChannelsRequest) async throws
      -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse

    /// See `BackupForGKEClient.listRestoreChannels`.
    func listRestoreChannels(
      byItem: ListRestoreChannelsRequest
    ) throws -> any AsyncSequence<RestoreChannel, Swift.Error>

    /// See `BackupForGKEClient.listRestoreChannels`.
    func listRestoreChannels(
      parent: Swift.String,
    ) throws -> any AsyncSequence<RestoreChannel, Swift.Error>

    /// See `BackupForGKEClient.getRestoreChannel`.
    func getRestoreChannel(request: GetRestoreChannelRequest) async throws
      -> GoogleCloudGKEBackupV1.RestoreChannel

    /// See `BackupForGKEClient.getRestoreChannel`.
    func getRestoreChannel(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.RestoreChannel

    /// See `BackupForGKEClient.updateRestoreChannel`.
    func updateRestoreChannel(request: UpdateRestoreChannelRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateRestoreChannel`.
    func updateRestoreChannel(withPolling: UpdateRestoreChannelRequest) async throws
      -> any GoogleCloudGax.PollableOperation<RestoreChannel>

    /// See `BackupForGKEClient.updateRestoreChannel`.
    func updateRestoreChannel(
      restoreChannel: RestoreChannel?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel>

    /// See `BackupForGKEClient.deleteRestoreChannel`.
    func deleteRestoreChannel(request: DeleteRestoreChannelRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteRestoreChannel`.
    func deleteRestoreChannel(withPolling: DeleteRestoreChannelRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.deleteRestoreChannel`.
    func deleteRestoreChannel(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listRestorePlanBindings`.
    func listRestorePlanBindings(request: ListRestorePlanBindingsRequest) async throws
      -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse

    /// See `BackupForGKEClient.listRestorePlanBindings`.
    func listRestorePlanBindings(
      byItem: ListRestorePlanBindingsRequest
    ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error>

    /// See `BackupForGKEClient.listRestorePlanBindings`.
    func listRestorePlanBindings(
      parent: Swift.String,
    ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error>

    /// See `BackupForGKEClient.getRestorePlanBinding`.
    func getRestorePlanBinding(request: GetRestorePlanBindingRequest) async throws
      -> GoogleCloudGKEBackupV1.RestorePlanBinding

    /// See `BackupForGKEClient.getRestorePlanBinding`.
    func getRestorePlanBinding(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.RestorePlanBinding

    /// See `BackupForGKEClient.createRestore`.
    func createRestore(request: CreateRestoreRequest) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createRestore`.
    func createRestore(withPolling: CreateRestoreRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Restore>

    /// See `BackupForGKEClient.createRestore`.
    func createRestore(
      parent: Swift.String,
      restore: Restore?,
      restoreId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Restore>

    /// See `BackupForGKEClient.listRestores`.
    func listRestores(request: ListRestoresRequest) async throws
      -> GoogleCloudGKEBackupV1.ListRestoresResponse

    /// See `BackupForGKEClient.listRestores`.
    func listRestores(
      byItem: ListRestoresRequest
    ) throws -> any AsyncSequence<Restore, Swift.Error>

    /// See `BackupForGKEClient.listRestores`.
    func listRestores(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Restore, Swift.Error>

    /// See `BackupForGKEClient.getRestore`.
    func getRestore(request: GetRestoreRequest) async throws -> GoogleCloudGKEBackupV1.Restore

    /// See `BackupForGKEClient.getRestore`.
    func getRestore(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.Restore

    /// See `BackupForGKEClient.updateRestore`.
    func updateRestore(request: UpdateRestoreRequest) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateRestore`.
    func updateRestore(withPolling: UpdateRestoreRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Restore>

    /// See `BackupForGKEClient.updateRestore`.
    func updateRestore(
      restore: Restore?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Restore>

    /// See `BackupForGKEClient.deleteRestore`.
    func deleteRestore(request: DeleteRestoreRequest) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteRestore`.
    func deleteRestore(withPolling: DeleteRestoreRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

    /// See `BackupForGKEClient.deleteRestore`.
    func deleteRestore(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listVolumeRestores`.
    func listVolumeRestores(request: ListVolumeRestoresRequest) async throws
      -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse

    /// See `BackupForGKEClient.listVolumeRestores`.
    func listVolumeRestores(
      byItem: ListVolumeRestoresRequest
    ) throws -> any AsyncSequence<VolumeRestore, Swift.Error>

    /// See `BackupForGKEClient.listVolumeRestores`.
    func listVolumeRestores(
      parent: Swift.String,
    ) throws -> any AsyncSequence<VolumeRestore, Swift.Error>

    /// See `BackupForGKEClient.getVolumeRestore`.
    func getVolumeRestore(request: GetVolumeRestoreRequest) async throws
      -> GoogleCloudGKEBackupV1.VolumeRestore

    /// See `BackupForGKEClient.getVolumeRestore`.
    func getVolumeRestore(
      name: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.VolumeRestore

    /// See `BackupForGKEClient.getBackupIndexDownloadUrl`.
    func getBackupIndexDownloadUrl(request: GetBackupIndexDownloadUrlRequest) async throws
      -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse

    /// See `BackupForGKEClient.getBackupIndexDownloadUrl`.
    func getBackupIndexDownloadUrl(
      backup: Swift.String,
    ) async throws -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse

    /// See `BackupForGKEClient.listLocations`.
    func listLocations(request: GoogleCloudLocation.ListLocationsRequest) async throws
      -> GoogleCloudLocation.ListLocationsResponse

    /// See `BackupForGKEClient.listLocations`.
    func listLocations(
      byItem: GoogleCloudLocation.ListLocationsRequest
    ) throws -> any AsyncSequence<GoogleCloudLocation.Location, Swift.Error>

    /// See `BackupForGKEClient.getLocation`.
    func getLocation(request: GoogleCloudLocation.GetLocationRequest) async throws
      -> GoogleCloudLocation.Location

    /// See `BackupForGKEClient.setIamPolicy`.
    func setIamPolicy(request: GoogleIAMV1.SetIamPolicyRequest) async throws -> GoogleIAMV1.Policy

    /// See `BackupForGKEClient.getIamPolicy`.
    func getIamPolicy(request: GoogleIAMV1.GetIamPolicyRequest) async throws -> GoogleIAMV1.Policy

    /// See `BackupForGKEClient.testIamPermissions`.
    func testIamPermissions(request: GoogleIAMV1.TestIamPermissionsRequest) async throws
      -> GoogleIAMV1.TestIamPermissionsResponse

    /// See `BackupForGKEClient.listOperations`.
    func listOperations(request: GoogleLongRunning.ListOperationsRequest) async throws
      -> GoogleLongRunning.ListOperationsResponse

    /// See `BackupForGKEClient.listOperations`.
    func listOperations(
      byItem: GoogleLongRunning.ListOperationsRequest
    ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error>

    /// See `BackupForGKEClient.listOperations`.
    func listOperations(
      name: Swift.String,
      filter: Swift.String,
    ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error>

    /// See `BackupForGKEClient.deleteOperation`.
    func deleteOperation(request: GoogleLongRunning.DeleteOperationRequest) async throws

    /// See `BackupForGKEClient.deleteOperation`.
    func deleteOperation(
      name: Swift.String,
    ) async throws

    /// See `BackupForGKEClient.cancelOperation`.
    func cancelOperation(request: GoogleLongRunning.CancelOperationRequest) async throws

    /// See `BackupForGKEClient.cancelOperation`.
    func cancelOperation(
      name: Swift.String,
    ) async throws

    /// See `BackupForGKEClient.createBackupPlan`.
    func createBackupPlan(
      request: CreateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createBackupPlan`.
    func createBackupPlan(
      withPolling: CreateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan>

    /// See `BackupForGKEClient.listBackupPlans`.
    func listBackupPlans(
      request: ListBackupPlansRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListBackupPlansResponse

    /// See `BackupForGKEClient.listBackupPlans`.
    func listBackupPlans(
      byItem: ListBackupPlansRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<BackupPlan, Swift.Error>

    /// See `BackupForGKEClient.getBackupPlan`.
    func getBackupPlan(
      request: GetBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.BackupPlan

    /// See `BackupForGKEClient.updateBackupPlan`.
    func updateBackupPlan(
      request: UpdateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateBackupPlan`.
    func updateBackupPlan(
      withPolling: UpdateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan>

    /// See `BackupForGKEClient.deleteBackupPlan`.
    func deleteBackupPlan(
      request: DeleteBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteBackupPlan`.
    func deleteBackupPlan(
      withPolling: DeleteBackupPlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.createBackupChannel`.
    func createBackupChannel(
      request: CreateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createBackupChannel`.
    func createBackupChannel(
      withPolling: CreateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel>

    /// See `BackupForGKEClient.listBackupChannels`.
    func listBackupChannels(
      request: ListBackupChannelsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse

    /// See `BackupForGKEClient.listBackupChannels`.
    func listBackupChannels(
      byItem: ListBackupChannelsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<BackupChannel, Swift.Error>

    /// See `BackupForGKEClient.getBackupChannel`.
    func getBackupChannel(
      request: GetBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.BackupChannel

    /// See `BackupForGKEClient.updateBackupChannel`.
    func updateBackupChannel(
      request: UpdateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateBackupChannel`.
    func updateBackupChannel(
      withPolling: UpdateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel>

    /// See `BackupForGKEClient.deleteBackupChannel`.
    func deleteBackupChannel(
      request: DeleteBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteBackupChannel`.
    func deleteBackupChannel(
      withPolling: DeleteBackupChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listBackupPlanBindings`.
    func listBackupPlanBindings(
      request: ListBackupPlanBindingsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse

    /// See `BackupForGKEClient.listBackupPlanBindings`.
    func listBackupPlanBindings(
      byItem: ListBackupPlanBindingsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error>

    /// See `BackupForGKEClient.getBackupPlanBinding`.
    func getBackupPlanBinding(
      request: GetBackupPlanBindingRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.BackupPlanBinding

    /// See `BackupForGKEClient.createBackup`.
    func createBackup(
      request: CreateBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createBackup`.
    func createBackup(
      withPolling: CreateBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Backup>

    /// See `BackupForGKEClient.listBackups`.
    func listBackups(
      request: ListBackupsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListBackupsResponse

    /// See `BackupForGKEClient.listBackups`.
    func listBackups(
      byItem: ListBackupsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Backup, Swift.Error>

    /// See `BackupForGKEClient.getBackup`.
    func getBackup(
      request: GetBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.Backup

    /// See `BackupForGKEClient.updateBackup`.
    func updateBackup(
      request: UpdateBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateBackup`.
    func updateBackup(
      withPolling: UpdateBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Backup>

    /// See `BackupForGKEClient.deleteBackup`.
    func deleteBackup(
      request: DeleteBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteBackup`.
    func deleteBackup(
      withPolling: DeleteBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listVolumeBackups`.
    func listVolumeBackups(
      request: ListVolumeBackupsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse

    /// See `BackupForGKEClient.listVolumeBackups`.
    func listVolumeBackups(
      byItem: ListVolumeBackupsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<VolumeBackup, Swift.Error>

    /// See `BackupForGKEClient.getVolumeBackup`.
    func getVolumeBackup(
      request: GetVolumeBackupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.VolumeBackup

    /// See `BackupForGKEClient.createRestorePlan`.
    func createRestorePlan(
      request: CreateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createRestorePlan`.
    func createRestorePlan(
      withPolling: CreateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan>

    /// See `BackupForGKEClient.listRestorePlans`.
    func listRestorePlans(
      request: ListRestorePlansRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListRestorePlansResponse

    /// See `BackupForGKEClient.listRestorePlans`.
    func listRestorePlans(
      byItem: ListRestorePlansRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<RestorePlan, Swift.Error>

    /// See `BackupForGKEClient.getRestorePlan`.
    func getRestorePlan(
      request: GetRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.RestorePlan

    /// See `BackupForGKEClient.updateRestorePlan`.
    func updateRestorePlan(
      request: UpdateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateRestorePlan`.
    func updateRestorePlan(
      withPolling: UpdateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan>

    /// See `BackupForGKEClient.deleteRestorePlan`.
    func deleteRestorePlan(
      request: DeleteRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteRestorePlan`.
    func deleteRestorePlan(
      withPolling: DeleteRestorePlanRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.createRestoreChannel`.
    func createRestoreChannel(
      request: CreateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createRestoreChannel`.
    func createRestoreChannel(
      withPolling: CreateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel>

    /// See `BackupForGKEClient.listRestoreChannels`.
    func listRestoreChannels(
      request: ListRestoreChannelsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse

    /// See `BackupForGKEClient.listRestoreChannels`.
    func listRestoreChannels(
      byItem: ListRestoreChannelsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<RestoreChannel, Swift.Error>

    /// See `BackupForGKEClient.getRestoreChannel`.
    func getRestoreChannel(
      request: GetRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.RestoreChannel

    /// See `BackupForGKEClient.updateRestoreChannel`.
    func updateRestoreChannel(
      request: UpdateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateRestoreChannel`.
    func updateRestoreChannel(
      withPolling: UpdateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel>

    /// See `BackupForGKEClient.deleteRestoreChannel`.
    func deleteRestoreChannel(
      request: DeleteRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteRestoreChannel`.
    func deleteRestoreChannel(
      withPolling: DeleteRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listRestorePlanBindings`.
    func listRestorePlanBindings(
      request: ListRestorePlanBindingsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse

    /// See `BackupForGKEClient.listRestorePlanBindings`.
    func listRestorePlanBindings(
      byItem: ListRestorePlanBindingsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error>

    /// See `BackupForGKEClient.getRestorePlanBinding`.
    func getRestorePlanBinding(
      request: GetRestorePlanBindingRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.RestorePlanBinding

    /// See `BackupForGKEClient.createRestore`.
    func createRestore(
      request: CreateRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.createRestore`.
    func createRestore(
      withPolling: CreateRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Restore>

    /// See `BackupForGKEClient.listRestores`.
    func listRestores(
      request: ListRestoresRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListRestoresResponse

    /// See `BackupForGKEClient.listRestores`.
    func listRestores(
      byItem: ListRestoresRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Restore, Swift.Error>

    /// See `BackupForGKEClient.getRestore`.
    func getRestore(
      request: GetRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.Restore

    /// See `BackupForGKEClient.updateRestore`.
    func updateRestore(
      request: UpdateRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.updateRestore`.
    func updateRestore(
      withPolling: UpdateRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Restore>

    /// See `BackupForGKEClient.deleteRestore`.
    func deleteRestore(
      request: DeleteRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `BackupForGKEClient.deleteRestore`.
    func deleteRestore(
      withPolling: DeleteRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `BackupForGKEClient.listVolumeRestores`.
    func listVolumeRestores(
      request: ListVolumeRestoresRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse

    /// See `BackupForGKEClient.listVolumeRestores`.
    func listVolumeRestores(
      byItem: ListVolumeRestoresRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<VolumeRestore, Swift.Error>

    /// See `BackupForGKEClient.getVolumeRestore`.
    func getVolumeRestore(
      request: GetVolumeRestoreRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.VolumeRestore

    /// See `BackupForGKEClient.getBackupIndexDownloadUrl`.
    func getBackupIndexDownloadUrl(
      request: GetBackupIndexDownloadUrlRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse

    /// See `BackupForGKEClient.listLocations`.
    func listLocations(
      request: GoogleCloudLocation.ListLocationsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudLocation.ListLocationsResponse

    /// See `BackupForGKEClient.listLocations`.
    func listLocations(
      byItem: GoogleCloudLocation.ListLocationsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<GoogleCloudLocation.Location, Swift.Error>

    /// See `BackupForGKEClient.getLocation`.
    func getLocation(
      request: GoogleCloudLocation.GetLocationRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudLocation.Location

    /// See `BackupForGKEClient.setIamPolicy`.
    func setIamPolicy(
      request: GoogleIAMV1.SetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleIAMV1.Policy

    /// See `BackupForGKEClient.getIamPolicy`.
    func getIamPolicy(
      request: GoogleIAMV1.GetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleIAMV1.Policy

    /// See `BackupForGKEClient.testIamPermissions`.
    func testIamPermissions(
      request: GoogleIAMV1.TestIamPermissionsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleIAMV1.TestIamPermissionsResponse

    /// See `BackupForGKEClient.listOperations`.
    func listOperations(
      request: GoogleLongRunning.ListOperationsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.ListOperationsResponse

    /// See `BackupForGKEClient.listOperations`.
    func listOperations(
      byItem: GoogleLongRunning.ListOperationsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error>

    /// See `BackupForGKEClient.deleteOperation`.
    func deleteOperation(
      request: GoogleLongRunning.DeleteOperationRequest, options: GoogleCloudGax.RequestOptions
    ) async throws

    /// See `BackupForGKEClient.cancelOperation`.
    func cancelOperation(
      request: GoogleLongRunning.CancelOperationRequest, options: GoogleCloudGax.RequestOptions
    ) async throws
  }
}

// Default implementations
extension Clients.BackupForGKEProtocol {
  public func createBackupPlan(request: CreateBackupPlanRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.createBackupPlan(request: request, options: .init())
  }

  public func createBackupPlan(
    request: CreateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createBackupPlan(withPolling: CreateBackupPlanRequest) async throws
    -> any GoogleCloudGax.PollableOperation<BackupPlan>
  {
    try await self.createBackupPlan(withPolling: withPolling, options: .init())
  }

  public func createBackupPlan(
    withPolling: CreateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupPlan>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func createBackupPlan(
    parent: Swift.String,
    backupPlan: BackupPlan?,
    backupPlanId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan> {
    let request = CreateBackupPlanRequest().with {
      $0.parent = parent
      $0.backupPlan = backupPlan
      $0.backupPlanId = backupPlanId
    }
    return try await self.createBackupPlan(withPolling: request)
  }

  public func listBackupPlans(request: ListBackupPlansRequest) async throws
    -> GoogleCloudGKEBackupV1.ListBackupPlansResponse
  {
    try await self.listBackupPlans(request: request, options: .init())
  }

  public func listBackupPlans(
    request: ListBackupPlansRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupPlansResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listBackupPlans(
    byItem: ListBackupPlansRequest
  ) throws -> any AsyncSequence<BackupPlan, Swift.Error> {
    try self.listBackupPlans(byItem: byItem, options: .init())
  }

  public func listBackupPlans(
    byItem: ListBackupPlansRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BackupPlan, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupPlansResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listBackupPlans(
    parent: Swift.String,
  ) throws -> any AsyncSequence<BackupPlan, Swift.Error> {
    let request = ListBackupPlansRequest().with {
      $0.parent = parent
    }
    return try self.listBackupPlans(byItem: request)
  }

  public func getBackupPlan(request: GetBackupPlanRequest) async throws
    -> GoogleCloudGKEBackupV1.BackupPlan
  {
    try await self.getBackupPlan(request: request, options: .init())
  }

  public func getBackupPlan(
    request: GetBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.BackupPlan {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getBackupPlan(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.BackupPlan {
    let request = GetBackupPlanRequest().with {
      $0.name = name
    }
    return try await self.getBackupPlan(request: request)
  }

  public func updateBackupPlan(request: UpdateBackupPlanRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.updateBackupPlan(request: request, options: .init())
  }

  public func updateBackupPlan(
    request: UpdateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateBackupPlan(withPolling: UpdateBackupPlanRequest) async throws
    -> any GoogleCloudGax.PollableOperation<BackupPlan>
  {
    try await self.updateBackupPlan(withPolling: withPolling, options: .init())
  }

  public func updateBackupPlan(
    withPolling: UpdateBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupPlan>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func updateBackupPlan(
    backupPlan: BackupPlan?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupPlan> {
    let request = UpdateBackupPlanRequest().with {
      $0.backupPlan = backupPlan
      $0.updateMask = updateMask
    }
    return try await self.updateBackupPlan(withPolling: request)
  }

  public func deleteBackupPlan(request: DeleteBackupPlanRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.deleteBackupPlan(request: request, options: .init())
  }

  public func deleteBackupPlan(
    request: DeleteBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteBackupPlan(withPolling: DeleteBackupPlanRequest) async throws
    -> any GoogleCloudGax.PollableOperation<Void>
  {
    try await self.deleteBackupPlan(withPolling: withPolling, options: .init())
  }

  public func deleteBackupPlan(
    withPolling: DeleteBackupPlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func deleteBackupPlan(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteBackupPlanRequest().with {
      $0.name = name
    }
    return try await self.deleteBackupPlan(withPolling: request)
  }

  public func createBackupChannel(request: CreateBackupChannelRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.createBackupChannel(request: request, options: .init())
  }

  public func createBackupChannel(
    request: CreateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createBackupChannel(withPolling: CreateBackupChannelRequest) async throws
    -> any GoogleCloudGax.PollableOperation<BackupChannel>
  {
    try await self.createBackupChannel(withPolling: withPolling, options: .init())
  }

  public func createBackupChannel(
    withPolling: CreateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupChannel>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func createBackupChannel(
    parent: Swift.String,
    backupChannel: BackupChannel?,
    backupChannelId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel> {
    let request = CreateBackupChannelRequest().with {
      $0.parent = parent
      $0.backupChannel = backupChannel
      $0.backupChannelId = backupChannelId
    }
    return try await self.createBackupChannel(withPolling: request)
  }

  public func listBackupChannels(request: ListBackupChannelsRequest) async throws
    -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse
  {
    try await self.listBackupChannels(request: request, options: .init())
  }

  public func listBackupChannels(
    request: ListBackupChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listBackupChannels(
    byItem: ListBackupChannelsRequest
  ) throws -> any AsyncSequence<BackupChannel, Swift.Error> {
    try self.listBackupChannels(byItem: byItem, options: .init())
  }

  public func listBackupChannels(
    byItem: ListBackupChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BackupChannel, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupChannelsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listBackupChannels(
    parent: Swift.String,
  ) throws -> any AsyncSequence<BackupChannel, Swift.Error> {
    let request = ListBackupChannelsRequest().with {
      $0.parent = parent
    }
    return try self.listBackupChannels(byItem: request)
  }

  public func getBackupChannel(request: GetBackupChannelRequest) async throws
    -> GoogleCloudGKEBackupV1.BackupChannel
  {
    try await self.getBackupChannel(request: request, options: .init())
  }

  public func getBackupChannel(
    request: GetBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.BackupChannel {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getBackupChannel(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.BackupChannel {
    let request = GetBackupChannelRequest().with {
      $0.name = name
    }
    return try await self.getBackupChannel(request: request)
  }

  public func updateBackupChannel(request: UpdateBackupChannelRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.updateBackupChannel(request: request, options: .init())
  }

  public func updateBackupChannel(
    request: UpdateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateBackupChannel(withPolling: UpdateBackupChannelRequest) async throws
    -> any GoogleCloudGax.PollableOperation<BackupChannel>
  {
    try await self.updateBackupChannel(withPolling: withPolling, options: .init())
  }

  public func updateBackupChannel(
    withPolling: UpdateBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BackupChannel>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func updateBackupChannel(
    backupChannel: BackupChannel?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<BackupChannel> {
    let request = UpdateBackupChannelRequest().with {
      $0.backupChannel = backupChannel
      $0.updateMask = updateMask
    }
    return try await self.updateBackupChannel(withPolling: request)
  }

  public func deleteBackupChannel(request: DeleteBackupChannelRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.deleteBackupChannel(request: request, options: .init())
  }

  public func deleteBackupChannel(
    request: DeleteBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteBackupChannel(withPolling: DeleteBackupChannelRequest) async throws
    -> any GoogleCloudGax.PollableOperation<Void>
  {
    try await self.deleteBackupChannel(withPolling: withPolling, options: .init())
  }

  public func deleteBackupChannel(
    withPolling: DeleteBackupChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func deleteBackupChannel(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteBackupChannelRequest().with {
      $0.name = name
    }
    return try await self.deleteBackupChannel(withPolling: request)
  }

  public func listBackupPlanBindings(request: ListBackupPlanBindingsRequest) async throws
    -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse
  {
    try await self.listBackupPlanBindings(request: request, options: .init())
  }

  public func listBackupPlanBindings(
    request: ListBackupPlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listBackupPlanBindings(
    byItem: ListBackupPlanBindingsRequest
  ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error> {
    try self.listBackupPlanBindings(byItem: byItem, options: .init())
  }

  public func listBackupPlanBindings(
    byItem: ListBackupPlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupPlanBindingsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listBackupPlanBindings(
    parent: Swift.String,
  ) throws -> any AsyncSequence<BackupPlanBinding, Swift.Error> {
    let request = ListBackupPlanBindingsRequest().with {
      $0.parent = parent
    }
    return try self.listBackupPlanBindings(byItem: request)
  }

  public func getBackupPlanBinding(request: GetBackupPlanBindingRequest) async throws
    -> GoogleCloudGKEBackupV1.BackupPlanBinding
  {
    try await self.getBackupPlanBinding(request: request, options: .init())
  }

  public func getBackupPlanBinding(
    request: GetBackupPlanBindingRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.BackupPlanBinding {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getBackupPlanBinding(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.BackupPlanBinding {
    let request = GetBackupPlanBindingRequest().with {
      $0.name = name
    }
    return try await self.getBackupPlanBinding(request: request)
  }

  public func createBackup(request: CreateBackupRequest) async throws -> GoogleLongRunning.Operation
  {
    try await self.createBackup(request: request, options: .init())
  }

  public func createBackup(
    request: CreateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createBackup(withPolling: CreateBackupRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Backup>
  {
    try await self.createBackup(withPolling: withPolling, options: .init())
  }

  public func createBackup(
    withPolling: CreateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Backup> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Backup>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func createBackup(
    parent: Swift.String,
    backup: Backup?,
    backupId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Backup> {
    let request = CreateBackupRequest().with {
      $0.parent = parent
      $0.backup = backup
      $0.backupId = backupId
    }
    return try await self.createBackup(withPolling: request)
  }

  public func listBackups(request: ListBackupsRequest) async throws
    -> GoogleCloudGKEBackupV1.ListBackupsResponse
  {
    try await self.listBackups(request: request, options: .init())
  }

  public func listBackups(
    request: ListBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListBackupsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listBackups(
    byItem: ListBackupsRequest
  ) throws -> any AsyncSequence<Backup, Swift.Error> {
    try self.listBackups(byItem: byItem, options: .init())
  }

  public func listBackups(
    byItem: ListBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Backup, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListBackupsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listBackups(
    parent: Swift.String,
  ) throws -> any AsyncSequence<Backup, Swift.Error> {
    let request = ListBackupsRequest().with {
      $0.parent = parent
    }
    return try self.listBackups(byItem: request)
  }

  public func getBackup(request: GetBackupRequest) async throws -> GoogleCloudGKEBackupV1.Backup {
    try await self.getBackup(request: request, options: .init())
  }

  public func getBackup(
    request: GetBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.Backup {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getBackup(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.Backup {
    let request = GetBackupRequest().with {
      $0.name = name
    }
    return try await self.getBackup(request: request)
  }

  public func updateBackup(request: UpdateBackupRequest) async throws -> GoogleLongRunning.Operation
  {
    try await self.updateBackup(request: request, options: .init())
  }

  public func updateBackup(
    request: UpdateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateBackup(withPolling: UpdateBackupRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Backup>
  {
    try await self.updateBackup(withPolling: withPolling, options: .init())
  }

  public func updateBackup(
    withPolling: UpdateBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Backup> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Backup>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func updateBackup(
    backup: Backup?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<Backup> {
    let request = UpdateBackupRequest().with {
      $0.backup = backup
      $0.updateMask = updateMask
    }
    return try await self.updateBackup(withPolling: request)
  }

  public func deleteBackup(request: DeleteBackupRequest) async throws -> GoogleLongRunning.Operation
  {
    try await self.deleteBackup(request: request, options: .init())
  }

  public func deleteBackup(
    request: DeleteBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteBackup(withPolling: DeleteBackupRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Void>
  {
    try await self.deleteBackup(withPolling: withPolling, options: .init())
  }

  public func deleteBackup(
    withPolling: DeleteBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func deleteBackup(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteBackupRequest().with {
      $0.name = name
    }
    return try await self.deleteBackup(withPolling: request)
  }

  public func listVolumeBackups(request: ListVolumeBackupsRequest) async throws
    -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse
  {
    try await self.listVolumeBackups(request: request, options: .init())
  }

  public func listVolumeBackups(
    request: ListVolumeBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listVolumeBackups(
    byItem: ListVolumeBackupsRequest
  ) throws -> any AsyncSequence<VolumeBackup, Swift.Error> {
    try self.listVolumeBackups(byItem: byItem, options: .init())
  }

  public func listVolumeBackups(
    byItem: ListVolumeBackupsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<VolumeBackup, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListVolumeBackupsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listVolumeBackups(
    parent: Swift.String,
  ) throws -> any AsyncSequence<VolumeBackup, Swift.Error> {
    let request = ListVolumeBackupsRequest().with {
      $0.parent = parent
    }
    return try self.listVolumeBackups(byItem: request)
  }

  public func getVolumeBackup(request: GetVolumeBackupRequest) async throws
    -> GoogleCloudGKEBackupV1.VolumeBackup
  {
    try await self.getVolumeBackup(request: request, options: .init())
  }

  public func getVolumeBackup(
    request: GetVolumeBackupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.VolumeBackup {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getVolumeBackup(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.VolumeBackup {
    let request = GetVolumeBackupRequest().with {
      $0.name = name
    }
    return try await self.getVolumeBackup(request: request)
  }

  public func createRestorePlan(request: CreateRestorePlanRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.createRestorePlan(request: request, options: .init())
  }

  public func createRestorePlan(
    request: CreateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createRestorePlan(withPolling: CreateRestorePlanRequest) async throws
    -> any GoogleCloudGax.PollableOperation<RestorePlan>
  {
    try await self.createRestorePlan(withPolling: withPolling, options: .init())
  }

  public func createRestorePlan(
    withPolling: CreateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestorePlan>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func createRestorePlan(
    parent: Swift.String,
    restorePlan: RestorePlan?,
    restorePlanId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan> {
    let request = CreateRestorePlanRequest().with {
      $0.parent = parent
      $0.restorePlan = restorePlan
      $0.restorePlanId = restorePlanId
    }
    return try await self.createRestorePlan(withPolling: request)
  }

  public func listRestorePlans(request: ListRestorePlansRequest) async throws
    -> GoogleCloudGKEBackupV1.ListRestorePlansResponse
  {
    try await self.listRestorePlans(request: request, options: .init())
  }

  public func listRestorePlans(
    request: ListRestorePlansRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestorePlansResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listRestorePlans(
    byItem: ListRestorePlansRequest
  ) throws -> any AsyncSequence<RestorePlan, Swift.Error> {
    try self.listRestorePlans(byItem: byItem, options: .init())
  }

  public func listRestorePlans(
    byItem: ListRestorePlansRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RestorePlan, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestorePlansResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listRestorePlans(
    parent: Swift.String,
  ) throws -> any AsyncSequence<RestorePlan, Swift.Error> {
    let request = ListRestorePlansRequest().with {
      $0.parent = parent
    }
    return try self.listRestorePlans(byItem: request)
  }

  public func getRestorePlan(request: GetRestorePlanRequest) async throws
    -> GoogleCloudGKEBackupV1.RestorePlan
  {
    try await self.getRestorePlan(request: request, options: .init())
  }

  public func getRestorePlan(
    request: GetRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.RestorePlan {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getRestorePlan(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.RestorePlan {
    let request = GetRestorePlanRequest().with {
      $0.name = name
    }
    return try await self.getRestorePlan(request: request)
  }

  public func updateRestorePlan(request: UpdateRestorePlanRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.updateRestorePlan(request: request, options: .init())
  }

  public func updateRestorePlan(
    request: UpdateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateRestorePlan(withPolling: UpdateRestorePlanRequest) async throws
    -> any GoogleCloudGax.PollableOperation<RestorePlan>
  {
    try await self.updateRestorePlan(withPolling: withPolling, options: .init())
  }

  public func updateRestorePlan(
    withPolling: UpdateRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestorePlan>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func updateRestorePlan(
    restorePlan: RestorePlan?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<RestorePlan> {
    let request = UpdateRestorePlanRequest().with {
      $0.restorePlan = restorePlan
      $0.updateMask = updateMask
    }
    return try await self.updateRestorePlan(withPolling: request)
  }

  public func deleteRestorePlan(request: DeleteRestorePlanRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.deleteRestorePlan(request: request, options: .init())
  }

  public func deleteRestorePlan(
    request: DeleteRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteRestorePlan(withPolling: DeleteRestorePlanRequest) async throws
    -> any GoogleCloudGax.PollableOperation<Void>
  {
    try await self.deleteRestorePlan(withPolling: withPolling, options: .init())
  }

  public func deleteRestorePlan(
    withPolling: DeleteRestorePlanRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func deleteRestorePlan(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteRestorePlanRequest().with {
      $0.name = name
    }
    return try await self.deleteRestorePlan(withPolling: request)
  }

  public func createRestoreChannel(request: CreateRestoreChannelRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.createRestoreChannel(request: request, options: .init())
  }

  public func createRestoreChannel(
    request: CreateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createRestoreChannel(withPolling: CreateRestoreChannelRequest) async throws
    -> any GoogleCloudGax.PollableOperation<RestoreChannel>
  {
    try await self.createRestoreChannel(withPolling: withPolling, options: .init())
  }

  public func createRestoreChannel(
    withPolling: CreateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestoreChannel>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func createRestoreChannel(
    parent: Swift.String,
    restoreChannel: RestoreChannel?,
    restoreChannelId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel> {
    let request = CreateRestoreChannelRequest().with {
      $0.parent = parent
      $0.restoreChannel = restoreChannel
      $0.restoreChannelId = restoreChannelId
    }
    return try await self.createRestoreChannel(withPolling: request)
  }

  public func listRestoreChannels(request: ListRestoreChannelsRequest) async throws
    -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse
  {
    try await self.listRestoreChannels(request: request, options: .init())
  }

  public func listRestoreChannels(
    request: ListRestoreChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listRestoreChannels(
    byItem: ListRestoreChannelsRequest
  ) throws -> any AsyncSequence<RestoreChannel, Swift.Error> {
    try self.listRestoreChannels(byItem: byItem, options: .init())
  }

  public func listRestoreChannels(
    byItem: ListRestoreChannelsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RestoreChannel, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestoreChannelsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listRestoreChannels(
    parent: Swift.String,
  ) throws -> any AsyncSequence<RestoreChannel, Swift.Error> {
    let request = ListRestoreChannelsRequest().with {
      $0.parent = parent
    }
    return try self.listRestoreChannels(byItem: request)
  }

  public func getRestoreChannel(request: GetRestoreChannelRequest) async throws
    -> GoogleCloudGKEBackupV1.RestoreChannel
  {
    try await self.getRestoreChannel(request: request, options: .init())
  }

  public func getRestoreChannel(
    request: GetRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.RestoreChannel {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getRestoreChannel(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.RestoreChannel {
    let request = GetRestoreChannelRequest().with {
      $0.name = name
    }
    return try await self.getRestoreChannel(request: request)
  }

  public func updateRestoreChannel(request: UpdateRestoreChannelRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.updateRestoreChannel(request: request, options: .init())
  }

  public func updateRestoreChannel(
    request: UpdateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateRestoreChannel(withPolling: UpdateRestoreChannelRequest) async throws
    -> any GoogleCloudGax.PollableOperation<RestoreChannel>
  {
    try await self.updateRestoreChannel(withPolling: withPolling, options: .init())
  }

  public func updateRestoreChannel(
    withPolling: UpdateRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<RestoreChannel>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func updateRestoreChannel(
    restoreChannel: RestoreChannel?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<RestoreChannel> {
    let request = UpdateRestoreChannelRequest().with {
      $0.restoreChannel = restoreChannel
      $0.updateMask = updateMask
    }
    return try await self.updateRestoreChannel(withPolling: request)
  }

  public func deleteRestoreChannel(request: DeleteRestoreChannelRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.deleteRestoreChannel(request: request, options: .init())
  }

  public func deleteRestoreChannel(
    request: DeleteRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteRestoreChannel(withPolling: DeleteRestoreChannelRequest) async throws
    -> any GoogleCloudGax.PollableOperation<Void>
  {
    try await self.deleteRestoreChannel(withPolling: withPolling, options: .init())
  }

  public func deleteRestoreChannel(
    withPolling: DeleteRestoreChannelRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func deleteRestoreChannel(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteRestoreChannelRequest().with {
      $0.name = name
    }
    return try await self.deleteRestoreChannel(withPolling: request)
  }

  public func listRestorePlanBindings(request: ListRestorePlanBindingsRequest) async throws
    -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse
  {
    try await self.listRestorePlanBindings(request: request, options: .init())
  }

  public func listRestorePlanBindings(
    request: ListRestorePlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listRestorePlanBindings(
    byItem: ListRestorePlanBindingsRequest
  ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error> {
    try self.listRestorePlanBindings(byItem: byItem, options: .init())
  }

  public func listRestorePlanBindings(
    byItem: ListRestorePlanBindingsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestorePlanBindingsResponse
      in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listRestorePlanBindings(
    parent: Swift.String,
  ) throws -> any AsyncSequence<RestorePlanBinding, Swift.Error> {
    let request = ListRestorePlanBindingsRequest().with {
      $0.parent = parent
    }
    return try self.listRestorePlanBindings(byItem: request)
  }

  public func getRestorePlanBinding(request: GetRestorePlanBindingRequest) async throws
    -> GoogleCloudGKEBackupV1.RestorePlanBinding
  {
    try await self.getRestorePlanBinding(request: request, options: .init())
  }

  public func getRestorePlanBinding(
    request: GetRestorePlanBindingRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.RestorePlanBinding {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getRestorePlanBinding(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.RestorePlanBinding {
    let request = GetRestorePlanBindingRequest().with {
      $0.name = name
    }
    return try await self.getRestorePlanBinding(request: request)
  }

  public func createRestore(request: CreateRestoreRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.createRestore(request: request, options: .init())
  }

  public func createRestore(
    request: CreateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createRestore(withPolling: CreateRestoreRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Restore>
  {
    try await self.createRestore(withPolling: withPolling, options: .init())
  }

  public func createRestore(
    withPolling: CreateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Restore> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Restore>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func createRestore(
    parent: Swift.String,
    restore: Restore?,
    restoreId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Restore> {
    let request = CreateRestoreRequest().with {
      $0.parent = parent
      $0.restore = restore
      $0.restoreId = restoreId
    }
    return try await self.createRestore(withPolling: request)
  }

  public func listRestores(request: ListRestoresRequest) async throws
    -> GoogleCloudGKEBackupV1.ListRestoresResponse
  {
    try await self.listRestores(request: request, options: .init())
  }

  public func listRestores(
    request: ListRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListRestoresResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listRestores(
    byItem: ListRestoresRequest
  ) throws -> any AsyncSequence<Restore, Swift.Error> {
    try self.listRestores(byItem: byItem, options: .init())
  }

  public func listRestores(
    byItem: ListRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Restore, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListRestoresResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listRestores(
    parent: Swift.String,
  ) throws -> any AsyncSequence<Restore, Swift.Error> {
    let request = ListRestoresRequest().with {
      $0.parent = parent
    }
    return try self.listRestores(byItem: request)
  }

  public func getRestore(request: GetRestoreRequest) async throws -> GoogleCloudGKEBackupV1.Restore
  {
    try await self.getRestore(request: request, options: .init())
  }

  public func getRestore(
    request: GetRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.Restore {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getRestore(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.Restore {
    let request = GetRestoreRequest().with {
      $0.name = name
    }
    return try await self.getRestore(request: request)
  }

  public func updateRestore(request: UpdateRestoreRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.updateRestore(request: request, options: .init())
  }

  public func updateRestore(
    request: UpdateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateRestore(withPolling: UpdateRestoreRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Restore>
  {
    try await self.updateRestore(withPolling: withPolling, options: .init())
  }

  public func updateRestore(
    withPolling: UpdateRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Restore> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Restore>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func updateRestore(
    restore: Restore?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<Restore> {
    let request = UpdateRestoreRequest().with {
      $0.restore = restore
      $0.updateMask = updateMask
    }
    return try await self.updateRestore(withPolling: request)
  }

  public func deleteRestore(request: DeleteRestoreRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.deleteRestore(request: request, options: .init())
  }

  public func deleteRestore(
    request: DeleteRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteRestore(withPolling: DeleteRestoreRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Void>
  {
    try await self.deleteRestore(withPolling: withPolling, options: .init())
  }

  public func deleteRestore(
    withPolling: DeleteRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: .init(done: false, result: nil), poll: poll)
  }

  public func deleteRestore(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteRestoreRequest().with {
      $0.name = name
    }
    return try await self.deleteRestore(withPolling: request)
  }

  public func listVolumeRestores(request: ListVolumeRestoresRequest) async throws
    -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse
  {
    try await self.listVolumeRestores(request: request, options: .init())
  }

  public func listVolumeRestores(
    request: ListVolumeRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listVolumeRestores(
    byItem: ListVolumeRestoresRequest
  ) throws -> any AsyncSequence<VolumeRestore, Swift.Error> {
    try self.listVolumeRestores(byItem: byItem, options: .init())
  }

  public func listVolumeRestores(
    byItem: ListVolumeRestoresRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<VolumeRestore, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudGKEBackupV1.ListVolumeRestoresResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listVolumeRestores(
    parent: Swift.String,
  ) throws -> any AsyncSequence<VolumeRestore, Swift.Error> {
    let request = ListVolumeRestoresRequest().with {
      $0.parent = parent
    }
    return try self.listVolumeRestores(byItem: request)
  }

  public func getVolumeRestore(request: GetVolumeRestoreRequest) async throws
    -> GoogleCloudGKEBackupV1.VolumeRestore
  {
    try await self.getVolumeRestore(request: request, options: .init())
  }

  public func getVolumeRestore(
    request: GetVolumeRestoreRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.VolumeRestore {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getVolumeRestore(
    name: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.VolumeRestore {
    let request = GetVolumeRestoreRequest().with {
      $0.name = name
    }
    return try await self.getVolumeRestore(request: request)
  }

  public func getBackupIndexDownloadUrl(request: GetBackupIndexDownloadUrlRequest) async throws
    -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse
  {
    try await self.getBackupIndexDownloadUrl(request: request, options: .init())
  }

  public func getBackupIndexDownloadUrl(
    request: GetBackupIndexDownloadUrlRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getBackupIndexDownloadUrl(
    backup: Swift.String,
  ) async throws -> GoogleCloudGKEBackupV1.GetBackupIndexDownloadUrlResponse {
    let request = GetBackupIndexDownloadUrlRequest().with {
      $0.backup = backup
    }
    return try await self.getBackupIndexDownloadUrl(request: request)
  }

  public func listLocations(request: GoogleCloudLocation.ListLocationsRequest) async throws
    -> GoogleCloudLocation.ListLocationsResponse
  {
    try await self.listLocations(request: request, options: .init())
  }

  public func listLocations(
    request: GoogleCloudLocation.ListLocationsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudLocation.ListLocationsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listLocations(
    byItem: GoogleCloudLocation.ListLocationsRequest
  ) throws -> any AsyncSequence<GoogleCloudLocation.Location, Swift.Error> {
    try self.listLocations(byItem: byItem, options: .init())
  }

  public func listLocations(
    byItem: GoogleCloudLocation.ListLocationsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<GoogleCloudLocation.Location, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudLocation.ListLocationsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func getLocation(request: GoogleCloudLocation.GetLocationRequest) async throws
    -> GoogleCloudLocation.Location
  {
    try await self.getLocation(request: request, options: .init())
  }

  public func getLocation(
    request: GoogleCloudLocation.GetLocationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudLocation.Location {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func setIamPolicy(request: GoogleIAMV1.SetIamPolicyRequest) async throws
    -> GoogleIAMV1.Policy
  {
    try await self.setIamPolicy(request: request, options: .init())
  }

  public func setIamPolicy(
    request: GoogleIAMV1.SetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.Policy {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getIamPolicy(request: GoogleIAMV1.GetIamPolicyRequest) async throws
    -> GoogleIAMV1.Policy
  {
    try await self.getIamPolicy(request: request, options: .init())
  }

  public func getIamPolicy(
    request: GoogleIAMV1.GetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.Policy {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func testIamPermissions(request: GoogleIAMV1.TestIamPermissionsRequest) async throws
    -> GoogleIAMV1.TestIamPermissionsResponse
  {
    try await self.testIamPermissions(request: request, options: .init())
  }

  public func testIamPermissions(
    request: GoogleIAMV1.TestIamPermissionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.TestIamPermissionsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listOperations(request: GoogleLongRunning.ListOperationsRequest) async throws
    -> GoogleLongRunning.ListOperationsResponse
  {
    try await self.listOperations(request: request, options: .init())
  }

  public func listOperations(
    request: GoogleLongRunning.ListOperationsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.ListOperationsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listOperations(
    byItem: GoogleLongRunning.ListOperationsRequest
  ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error> {
    try self.listOperations(byItem: byItem, options: .init())
  }

  public func listOperations(
    byItem: GoogleLongRunning.ListOperationsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleLongRunning.ListOperationsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listOperations(
    name: Swift.String,
    filter: Swift.String,
  ) throws -> any AsyncSequence<GoogleLongRunning.Operation, Swift.Error> {
    let request = GoogleLongRunning.ListOperationsRequest().with {
      $0.name = name
      $0.filter = filter
    }
    return try self.listOperations(byItem: request)
  }

  public func getOperation(request: GoogleLongRunning.GetOperationRequest) async throws
    -> GoogleLongRunning.Operation
  {
    try await self.getOperation(request: request, options: .init())
  }

  public func getOperation(
    request: GoogleLongRunning.GetOperationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getOperation(
    name: Swift.String,
  ) async throws -> GoogleLongRunning.Operation {
    let request = GoogleLongRunning.GetOperationRequest().with {
      $0.name = name
    }
    return try await self.getOperation(request: request)
  }

  public func deleteOperation(request: GoogleLongRunning.DeleteOperationRequest) async throws {
    try await self.deleteOperation(request: request, options: .init())
  }

  public func deleteOperation(
    request: GoogleLongRunning.DeleteOperationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteOperation(
    name: Swift.String,
  ) async throws {
    let request = GoogleLongRunning.DeleteOperationRequest().with {
      $0.name = name
    }
    try await self.deleteOperation(request: request)
  }

  public func cancelOperation(request: GoogleLongRunning.CancelOperationRequest) async throws {
    try await self.cancelOperation(request: request, options: .init())
  }

  public func cancelOperation(
    request: GoogleLongRunning.CancelOperationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func cancelOperation(
    name: Swift.String,
  ) async throws {
    let request = GoogleLongRunning.CancelOperationRequest().with {
      $0.name = name
    }
    try await self.cancelOperation(request: request)
  }
}
