// 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

/// Database Migration service
///
/// @Snippet(path: "DataMigrationServiceQuickstart")
public class DataMigrationServiceClient: Clients.DataMigrationServiceProtocol {
  let inner: any Clients.DataMigrationServiceStub
  let pollingErrorPolicy: GoogleCloudGax.PollingErrorPolicy
  let pollingBackoffPolicy: GoogleCloudGax.BackoffPolicy

  /// Creates a new `DataMigrationServiceClient` instance.
  public init(_ options: GoogleCloudGax.ClientOptions = .init()) throws {
    var inner: any Clients.DataMigrationServiceStub = try Clients.DataMigrationServiceTransport(
      options)
    inner = Clients.DataMigrationServiceRetry(inner, options: options)
    if let logger = options.logger {
      inner = Clients.DataMigrationServiceLogging(inner, logger: logger)
    }
    self.inner = inner
    self.pollingErrorPolicy = options.pollingErrorPolicy
    self.pollingBackoffPolicy = options.pollingBackoffPolicy
  }

  /// Lists migration jobs in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_ListMigrationJobs")
  public func listMigrationJobs(
    request: ListMigrationJobsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListMigrationJobsResponse {
    try await self.inner.listMigrationJobs(request: request, options: options)
  }

  /// Lists migration jobs in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_ListMigrationJobs")
  public func listMigrationJobs(
    byItem: ListMigrationJobsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MigrationJob, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListMigrationJobsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listMigrationJobs(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets details of a single migration job.
  ///
  /// @Snippet(path: "DataMigrationService_GetMigrationJob")
  public func getMigrationJob(
    request: GetMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.MigrationJob {
    try await self.inner.getMigrationJob(request: request, options: options)
  }

  /// Creates a new migration job in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreateMigrationJob")
  public func createMigrationJob(
    request: CreateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createMigrationJob(request: request, options: options)
  }

  /// Creates a new migration job in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreateMigrationJob")
  public func createMigrationJob(
    withPolling: CreateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.createMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Updates the parameters of a single migration job.
  ///
  /// @Snippet(path: "DataMigrationService_UpdateMigrationJob")
  public func updateMigrationJob(
    request: UpdateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateMigrationJob(request: request, options: options)
  }

  /// Updates the parameters of a single migration job.
  ///
  /// @Snippet(path: "DataMigrationService_UpdateMigrationJob")
  public func updateMigrationJob(
    withPolling: UpdateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.updateMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 a single migration job.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteMigrationJob")
  public func deleteMigrationJob(
    request: DeleteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteMigrationJob(request: request, options: options)
  }

  /// Deletes a single migration job.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteMigrationJob")
  public func deleteMigrationJob(
    withPolling: DeleteMigrationJobRequest, 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.deleteMigrationJob(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,
    )
  }

  /// Start an already created migration job.
  ///
  /// @Snippet(path: "DataMigrationService_StartMigrationJob")
  public func startMigrationJob(
    request: StartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.startMigrationJob(request: request, options: options)
  }

  /// Start an already created migration job.
  ///
  /// @Snippet(path: "DataMigrationService_StartMigrationJob")
  public func startMigrationJob(
    withPolling: StartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.startMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Stops a running migration job.
  ///
  /// @Snippet(path: "DataMigrationService_StopMigrationJob")
  public func stopMigrationJob(
    request: StopMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.stopMigrationJob(request: request, options: options)
  }

  /// Stops a running migration job.
  ///
  /// @Snippet(path: "DataMigrationService_StopMigrationJob")
  public func stopMigrationJob(
    withPolling: StopMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.stopMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Resume a migration job that is currently stopped and is resumable (was
  /// stopped during CDC phase).
  ///
  /// @Snippet(path: "DataMigrationService_ResumeMigrationJob")
  public func resumeMigrationJob(
    request: ResumeMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.resumeMigrationJob(request: request, options: options)
  }

  /// Resume a migration job that is currently stopped and is resumable (was
  /// stopped during CDC phase).
  ///
  /// @Snippet(path: "DataMigrationService_ResumeMigrationJob")
  public func resumeMigrationJob(
    withPolling: ResumeMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.resumeMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Promote a migration job, stopping replication to the destination and
  /// promoting the destination to be a standalone database.
  ///
  /// @Snippet(path: "DataMigrationService_PromoteMigrationJob")
  public func promoteMigrationJob(
    request: PromoteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.promoteMigrationJob(request: request, options: options)
  }

  /// Promote a migration job, stopping replication to the destination and
  /// promoting the destination to be a standalone database.
  ///
  /// @Snippet(path: "DataMigrationService_PromoteMigrationJob")
  public func promoteMigrationJob(
    withPolling: PromoteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.promoteMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Verify a migration job, making sure the destination can reach the source
  /// and that all configuration and prerequisites are met.
  ///
  /// @Snippet(path: "DataMigrationService_VerifyMigrationJob")
  public func verifyMigrationJob(
    request: VerifyMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.verifyMigrationJob(request: request, options: options)
  }

  /// Verify a migration job, making sure the destination can reach the source
  /// and that all configuration and prerequisites are met.
  ///
  /// @Snippet(path: "DataMigrationService_VerifyMigrationJob")
  public func verifyMigrationJob(
    withPolling: VerifyMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.verifyMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Restart a stopped or failed migration job, resetting the destination
  /// instance to its original state and starting the migration process from
  /// scratch.
  ///
  /// @Snippet(path: "DataMigrationService_RestartMigrationJob")
  public func restartMigrationJob(
    request: RestartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.restartMigrationJob(request: request, options: options)
  }

  /// Restart a stopped or failed migration job, resetting the destination
  /// instance to its original state and starting the migration process from
  /// scratch.
  ///
  /// @Snippet(path: "DataMigrationService_RestartMigrationJob")
  public func restartMigrationJob(
    withPolling: RestartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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 MigrationJob(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.restartMigrationJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MigrationJob>.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,
    )
  }

  /// Generate a SSH configuration script to configure the reverse SSH
  /// connectivity.
  ///
  /// @Snippet(path: "DataMigrationService_GenerateSshScript")
  public func generateSshScript(
    request: GenerateSshScriptRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.SshScript {
    try await self.inner.generateSshScript(request: request, options: options)
  }

  /// Generate a TCP Proxy configuration script to configure a cloud-hosted VM
  /// running a TCP Proxy.
  ///
  /// @Snippet(path: "DataMigrationService_GenerateTcpProxyScript")
  public func generateTcpProxyScript(
    request: GenerateTcpProxyScriptRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.TcpProxyScript {
    try await self.inner.generateTcpProxyScript(request: request, options: options)
  }

  /// Retrieves a list of all connection profiles in a given project and
  /// location.
  ///
  /// @Snippet(path: "DataMigrationService_ListConnectionProfiles")
  public func listConnectionProfiles(
    request: ListConnectionProfilesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListConnectionProfilesResponse {
    try await self.inner.listConnectionProfiles(request: request, options: options)
  }

  /// Retrieves a list of all connection profiles in a given project and
  /// location.
  ///
  /// @Snippet(path: "DataMigrationService_ListConnectionProfiles")
  public func listConnectionProfiles(
    byItem: ListConnectionProfilesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<ConnectionProfile, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListConnectionProfilesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listConnectionProfiles(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets details of a single connection profile.
  ///
  /// @Snippet(path: "DataMigrationService_GetConnectionProfile")
  public func getConnectionProfile(
    request: GetConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ConnectionProfile {
    try await self.inner.getConnectionProfile(request: request, options: options)
  }

  /// Creates a new connection profile in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreateConnectionProfile")
  public func createConnectionProfile(
    request: CreateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createConnectionProfile(request: request, options: options)
  }

  /// Creates a new connection profile in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreateConnectionProfile")
  public func createConnectionProfile(
    withPolling: CreateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConnectionProfile>.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 ConnectionProfile(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.createConnectionProfile(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConnectionProfile>.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,
    )
  }

  /// Update the configuration of a single connection profile.
  ///
  /// @Snippet(path: "DataMigrationService_UpdateConnectionProfile")
  public func updateConnectionProfile(
    request: UpdateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateConnectionProfile(request: request, options: options)
  }

  /// Update the configuration of a single connection profile.
  ///
  /// @Snippet(path: "DataMigrationService_UpdateConnectionProfile")
  public func updateConnectionProfile(
    withPolling: UpdateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConnectionProfile>.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 ConnectionProfile(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.updateConnectionProfile(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConnectionProfile>.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 a single Database Migration Service connection profile.
  /// A connection profile can only be deleted if it is not in use by any
  /// active migration jobs.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteConnectionProfile")
  public func deleteConnectionProfile(
    request: DeleteConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteConnectionProfile(request: request, options: options)
  }

  /// Deletes a single Database Migration Service connection profile.
  /// A connection profile can only be deleted if it is not in use by any
  /// active migration jobs.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteConnectionProfile")
  public func deleteConnectionProfile(
    withPolling: DeleteConnectionProfileRequest, 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.deleteConnectionProfile(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 private connection in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreatePrivateConnection")
  public func createPrivateConnection(
    request: CreatePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createPrivateConnection(request: request, options: options)
  }

  /// Creates a new private connection in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreatePrivateConnection")
  public func createPrivateConnection(
    withPolling: CreatePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PrivateConnection> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PrivateConnection>.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 PrivateConnection(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.createPrivateConnection(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<PrivateConnection>.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,
    )
  }

  /// Gets details of a single private connection.
  ///
  /// @Snippet(path: "DataMigrationService_GetPrivateConnection")
  public func getPrivateConnection(
    request: GetPrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.PrivateConnection {
    try await self.inner.getPrivateConnection(request: request, options: options)
  }

  /// Retrieves a list of private connections in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_ListPrivateConnections")
  public func listPrivateConnections(
    request: ListPrivateConnectionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListPrivateConnectionsResponse {
    try await self.inner.listPrivateConnections(request: request, options: options)
  }

  /// Retrieves a list of private connections in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_ListPrivateConnections")
  public func listPrivateConnections(
    byItem: ListPrivateConnectionsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<PrivateConnection, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListPrivateConnectionsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listPrivateConnections(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Deletes a single Database Migration Service private connection.
  ///
  /// @Snippet(path: "DataMigrationService_DeletePrivateConnection")
  public func deletePrivateConnection(
    request: DeletePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deletePrivateConnection(request: request, options: options)
  }

  /// Deletes a single Database Migration Service private connection.
  ///
  /// @Snippet(path: "DataMigrationService_DeletePrivateConnection")
  public func deletePrivateConnection(
    withPolling: DeletePrivateConnectionRequest, 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.deletePrivateConnection(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,
    )
  }

  /// Gets details of a single conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_GetConversionWorkspace")
  public func getConversionWorkspace(
    request: GetConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ConversionWorkspace {
    try await self.inner.getConversionWorkspace(request: request, options: options)
  }

  /// Lists conversion workspaces in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_ListConversionWorkspaces")
  public func listConversionWorkspaces(
    request: ListConversionWorkspacesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListConversionWorkspacesResponse {
    try await self.inner.listConversionWorkspaces(request: request, options: options)
  }

  /// Lists conversion workspaces in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_ListConversionWorkspaces")
  public func listConversionWorkspaces(
    byItem: ListConversionWorkspacesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<ConversionWorkspace, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListConversionWorkspacesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listConversionWorkspaces(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Creates a new conversion workspace in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreateConversionWorkspace")
  public func createConversionWorkspace(
    request: CreateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createConversionWorkspace(request: request, options: options)
  }

  /// Creates a new conversion workspace in a given project and location.
  ///
  /// @Snippet(path: "DataMigrationService_CreateConversionWorkspace")
  public func createConversionWorkspace(
    withPolling: CreateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.createConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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,
    )
  }

  /// Updates the parameters of a single conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_UpdateConversionWorkspace")
  public func updateConversionWorkspace(
    request: UpdateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateConversionWorkspace(request: request, options: options)
  }

  /// Updates the parameters of a single conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_UpdateConversionWorkspace")
  public func updateConversionWorkspace(
    withPolling: UpdateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.updateConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 a single conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteConversionWorkspace")
  public func deleteConversionWorkspace(
    request: DeleteConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteConversionWorkspace(request: request, options: options)
  }

  /// Deletes a single conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteConversionWorkspace")
  public func deleteConversionWorkspace(
    withPolling: DeleteConversionWorkspaceRequest, 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.deleteConversionWorkspace(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 mapping rule for a given conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_CreateMappingRule")
  public func createMappingRule(
    request: CreateMappingRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.MappingRule {
    try await self.inner.createMappingRule(request: request, options: options)
  }

  /// Deletes a single mapping rule.
  ///
  /// @Snippet(path: "DataMigrationService_DeleteMappingRule")
  public func deleteMappingRule(
    request: DeleteMappingRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    try await self.inner.deleteMappingRule(request: request, options: options)
  }

  /// Lists the mapping rules for a specific conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_ListMappingRules")
  public func listMappingRules(
    request: ListMappingRulesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListMappingRulesResponse {
    try await self.inner.listMappingRules(request: request, options: options)
  }

  /// Lists the mapping rules for a specific conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_ListMappingRules")
  public func listMappingRules(
    byItem: ListMappingRulesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MappingRule, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListMappingRulesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listMappingRules(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets the details of a mapping rule.
  ///
  /// @Snippet(path: "DataMigrationService_GetMappingRule")
  public func getMappingRule(
    request: GetMappingRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.MappingRule {
    try await self.inner.getMappingRule(request: request, options: options)
  }

  /// Imports a snapshot of the source database into the
  /// conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_SeedConversionWorkspace")
  public func seedConversionWorkspace(
    request: SeedConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.seedConversionWorkspace(request: request, options: options)
  }

  /// Imports a snapshot of the source database into the
  /// conversion workspace.
  ///
  /// @Snippet(path: "DataMigrationService_SeedConversionWorkspace")
  public func seedConversionWorkspace(
    withPolling: SeedConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.seedConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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,
    )
  }

  /// Imports the mapping rules for a given conversion workspace.
  /// Supports various formats of external rules files.
  ///
  /// @Snippet(path: "DataMigrationService_ImportMappingRules")
  public func importMappingRules(
    request: ImportMappingRulesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.importMappingRules(request: request, options: options)
  }

  /// Imports the mapping rules for a given conversion workspace.
  /// Supports various formats of external rules files.
  ///
  /// @Snippet(path: "DataMigrationService_ImportMappingRules")
  public func importMappingRules(
    withPolling: ImportMappingRulesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.importMappingRules(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 draft tree schema for the destination database.
  ///
  /// @Snippet(path: "DataMigrationService_ConvertConversionWorkspace")
  public func convertConversionWorkspace(
    request: ConvertConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.convertConversionWorkspace(request: request, options: options)
  }

  /// Creates a draft tree schema for the destination database.
  ///
  /// @Snippet(path: "DataMigrationService_ConvertConversionWorkspace")
  public func convertConversionWorkspace(
    withPolling: ConvertConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.convertConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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,
    )
  }

  /// Marks all the data in the conversion workspace as committed.
  ///
  /// @Snippet(path: "DataMigrationService_CommitConversionWorkspace")
  public func commitConversionWorkspace(
    request: CommitConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.commitConversionWorkspace(request: request, options: options)
  }

  /// Marks all the data in the conversion workspace as committed.
  ///
  /// @Snippet(path: "DataMigrationService_CommitConversionWorkspace")
  public func commitConversionWorkspace(
    withPolling: CommitConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.commitConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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,
    )
  }

  /// Rolls back a conversion workspace to the last committed snapshot.
  ///
  /// @Snippet(path: "DataMigrationService_RollbackConversionWorkspace")
  public func rollbackConversionWorkspace(
    request: RollbackConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.rollbackConversionWorkspace(request: request, options: options)
  }

  /// Rolls back a conversion workspace to the last committed snapshot.
  ///
  /// @Snippet(path: "DataMigrationService_RollbackConversionWorkspace")
  public func rollbackConversionWorkspace(
    withPolling: RollbackConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.rollbackConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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,
    )
  }

  /// Applies draft tree onto a specific destination database.
  ///
  /// @Snippet(path: "DataMigrationService_ApplyConversionWorkspace")
  public func applyConversionWorkspace(
    request: ApplyConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.applyConversionWorkspace(request: request, options: options)
  }

  /// Applies draft tree onto a specific destination database.
  ///
  /// @Snippet(path: "DataMigrationService_ApplyConversionWorkspace")
  public func applyConversionWorkspace(
    withPolling: ApplyConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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 ConversionWorkspace(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.applyConversionWorkspace(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<ConversionWorkspace>.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,
    )
  }

  /// Describes the database entities tree for a specific conversion workspace
  /// and a specific tree type.
  ///
  /// Database entities are not resources like conversion workspaces or mapping
  /// rules, and they can't be created, updated or deleted. Instead, they are
  /// simple data objects describing the structure of the client database.
  ///
  /// @Snippet(path: "DataMigrationService_DescribeDatabaseEntities")
  public func describeDatabaseEntities(
    request: DescribeDatabaseEntitiesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse {
    try await self.inner.describeDatabaseEntities(request: request, options: options)
  }

  /// Describes the database entities tree for a specific conversion workspace
  /// and a specific tree type.
  ///
  /// Database entities are not resources like conversion workspaces or mapping
  /// rules, and they can't be created, updated or deleted. Instead, they are
  /// simple data objects describing the structure of the client database.
  ///
  /// @Snippet(path: "DataMigrationService_DescribeDatabaseEntities")
  public func describeDatabaseEntities(
    byItem: DescribeDatabaseEntitiesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<DatabaseEntity, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.describeDatabaseEntities(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Searches/lists the background jobs for a specific
  /// conversion workspace.
  ///
  /// The background jobs are not resources like conversion workspaces or
  /// mapping rules, and they can't be created, updated or deleted.
  /// Instead, they are a way to expose the data plane jobs log.
  ///
  /// @Snippet(path: "DataMigrationService_SearchBackgroundJobs")
  public func searchBackgroundJobs(
    request: SearchBackgroundJobsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.SearchBackgroundJobsResponse {
    try await self.inner.searchBackgroundJobs(request: request, options: options)
  }

  /// Retrieves a list of committed revisions of a specific conversion
  /// workspace.
  ///
  /// @Snippet(path: "DataMigrationService_DescribeConversionWorkspaceRevisions")
  public func describeConversionWorkspaceRevisions(
    request: DescribeConversionWorkspaceRevisionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.DescribeConversionWorkspaceRevisionsResponse {
    try await self.inner.describeConversionWorkspaceRevisions(request: request, options: options)
  }

  /// Fetches a set of static IP addresses that need to be allowlisted by the
  /// customer when using the static-IP connectivity method.
  ///
  /// @Snippet(path: "DataMigrationService_FetchStaticIps")
  public func fetchStaticIps(
    request: FetchStaticIpsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.FetchStaticIpsResponse {
    try await self.inner.fetchStaticIps(request: request, options: options)
  }

  /// Lists information about the supported locations for this service.
  ///
  /// @Snippet(path: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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: "DataMigrationService_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 `DataMigrationServiceClient`.
  ///
  /// To mock `DataMigrationServiceClient` change your functions to receive
  /// `some DataMigrationServiceProtocol` or `any DataMigrationServiceProtocol`
  /// and pass a mock implementation in your tests.
  public protocol DataMigrationServiceProtocol {
    /// See `DataMigrationServiceClient.listMigrationJobs`.
    func listMigrationJobs(request: ListMigrationJobsRequest) async throws
      -> GoogleCloudDMSV1.ListMigrationJobsResponse

    /// See `DataMigrationServiceClient.listMigrationJobs`.
    func listMigrationJobs(
      byItem: ListMigrationJobsRequest
    ) throws -> any AsyncSequence<MigrationJob, Swift.Error>

    /// See `DataMigrationServiceClient.listMigrationJobs`.
    func listMigrationJobs(
      parent: Swift.String,
    ) throws -> any AsyncSequence<MigrationJob, Swift.Error>

    /// See `DataMigrationServiceClient.getMigrationJob`.
    func getMigrationJob(request: GetMigrationJobRequest) async throws
      -> GoogleCloudDMSV1.MigrationJob

    /// See `DataMigrationServiceClient.getMigrationJob`.
    func getMigrationJob(
      name: Swift.String,
    ) async throws -> GoogleCloudDMSV1.MigrationJob

    /// See `DataMigrationServiceClient.createMigrationJob`.
    func createMigrationJob(request: CreateMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createMigrationJob`.
    func createMigrationJob(withPolling: CreateMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.createMigrationJob`.
    func createMigrationJob(
      parent: Swift.String,
      migrationJob: MigrationJob?,
      migrationJobId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.updateMigrationJob`.
    func updateMigrationJob(request: UpdateMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.updateMigrationJob`.
    func updateMigrationJob(withPolling: UpdateMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.updateMigrationJob`.
    func updateMigrationJob(
      migrationJob: MigrationJob?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.deleteMigrationJob`.
    func deleteMigrationJob(request: DeleteMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deleteMigrationJob`.
    func deleteMigrationJob(withPolling: DeleteMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `DataMigrationServiceClient.startMigrationJob`.
    func startMigrationJob(request: StartMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.startMigrationJob`.
    func startMigrationJob(withPolling: StartMigrationJobRequest) async throws -> any GoogleCloudGax
      .PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.stopMigrationJob`.
    func stopMigrationJob(request: StopMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.stopMigrationJob`.
    func stopMigrationJob(withPolling: StopMigrationJobRequest) async throws -> any GoogleCloudGax
      .PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.resumeMigrationJob`.
    func resumeMigrationJob(request: ResumeMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.resumeMigrationJob`.
    func resumeMigrationJob(withPolling: ResumeMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.promoteMigrationJob`.
    func promoteMigrationJob(request: PromoteMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.promoteMigrationJob`.
    func promoteMigrationJob(withPolling: PromoteMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.verifyMigrationJob`.
    func verifyMigrationJob(request: VerifyMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.verifyMigrationJob`.
    func verifyMigrationJob(withPolling: VerifyMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.restartMigrationJob`.
    func restartMigrationJob(request: RestartMigrationJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.restartMigrationJob`.
    func restartMigrationJob(withPolling: RestartMigrationJobRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.generateSshScript`.
    func generateSshScript(request: GenerateSshScriptRequest) async throws
      -> GoogleCloudDMSV1.SshScript

    /// See `DataMigrationServiceClient.generateTcpProxyScript`.
    func generateTcpProxyScript(request: GenerateTcpProxyScriptRequest) async throws
      -> GoogleCloudDMSV1.TcpProxyScript

    /// See `DataMigrationServiceClient.listConnectionProfiles`.
    func listConnectionProfiles(request: ListConnectionProfilesRequest) async throws
      -> GoogleCloudDMSV1.ListConnectionProfilesResponse

    /// See `DataMigrationServiceClient.listConnectionProfiles`.
    func listConnectionProfiles(
      byItem: ListConnectionProfilesRequest
    ) throws -> any AsyncSequence<ConnectionProfile, Swift.Error>

    /// See `DataMigrationServiceClient.listConnectionProfiles`.
    func listConnectionProfiles(
      parent: Swift.String,
    ) throws -> any AsyncSequence<ConnectionProfile, Swift.Error>

    /// See `DataMigrationServiceClient.getConnectionProfile`.
    func getConnectionProfile(request: GetConnectionProfileRequest) async throws
      -> GoogleCloudDMSV1.ConnectionProfile

    /// See `DataMigrationServiceClient.getConnectionProfile`.
    func getConnectionProfile(
      name: Swift.String,
    ) async throws -> GoogleCloudDMSV1.ConnectionProfile

    /// See `DataMigrationServiceClient.createConnectionProfile`.
    func createConnectionProfile(request: CreateConnectionProfileRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createConnectionProfile`.
    func createConnectionProfile(withPolling: CreateConnectionProfileRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConnectionProfile>

    /// See `DataMigrationServiceClient.createConnectionProfile`.
    func createConnectionProfile(
      parent: Swift.String,
      connectionProfile: ConnectionProfile?,
      connectionProfileId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile>

    /// See `DataMigrationServiceClient.updateConnectionProfile`.
    func updateConnectionProfile(request: UpdateConnectionProfileRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.updateConnectionProfile`.
    func updateConnectionProfile(withPolling: UpdateConnectionProfileRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConnectionProfile>

    /// See `DataMigrationServiceClient.updateConnectionProfile`.
    func updateConnectionProfile(
      connectionProfile: ConnectionProfile?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile>

    /// See `DataMigrationServiceClient.deleteConnectionProfile`.
    func deleteConnectionProfile(request: DeleteConnectionProfileRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deleteConnectionProfile`.
    func deleteConnectionProfile(withPolling: DeleteConnectionProfileRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `DataMigrationServiceClient.createPrivateConnection`.
    func createPrivateConnection(request: CreatePrivateConnectionRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createPrivateConnection`.
    func createPrivateConnection(withPolling: CreatePrivateConnectionRequest) async throws
      -> any GoogleCloudGax.PollableOperation<PrivateConnection>

    /// See `DataMigrationServiceClient.createPrivateConnection`.
    func createPrivateConnection(
      parent: Swift.String,
      privateConnection: PrivateConnection?,
      privateConnectionId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<PrivateConnection>

    /// See `DataMigrationServiceClient.getPrivateConnection`.
    func getPrivateConnection(request: GetPrivateConnectionRequest) async throws
      -> GoogleCloudDMSV1.PrivateConnection

    /// See `DataMigrationServiceClient.getPrivateConnection`.
    func getPrivateConnection(
      name: Swift.String,
    ) async throws -> GoogleCloudDMSV1.PrivateConnection

    /// See `DataMigrationServiceClient.listPrivateConnections`.
    func listPrivateConnections(request: ListPrivateConnectionsRequest) async throws
      -> GoogleCloudDMSV1.ListPrivateConnectionsResponse

    /// See `DataMigrationServiceClient.listPrivateConnections`.
    func listPrivateConnections(
      byItem: ListPrivateConnectionsRequest
    ) throws -> any AsyncSequence<PrivateConnection, Swift.Error>

    /// See `DataMigrationServiceClient.listPrivateConnections`.
    func listPrivateConnections(
      parent: Swift.String,
    ) throws -> any AsyncSequence<PrivateConnection, Swift.Error>

    /// See `DataMigrationServiceClient.deletePrivateConnection`.
    func deletePrivateConnection(request: DeletePrivateConnectionRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deletePrivateConnection`.
    func deletePrivateConnection(withPolling: DeletePrivateConnectionRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `DataMigrationServiceClient.getConversionWorkspace`.
    func getConversionWorkspace(request: GetConversionWorkspaceRequest) async throws
      -> GoogleCloudDMSV1.ConversionWorkspace

    /// See `DataMigrationServiceClient.getConversionWorkspace`.
    func getConversionWorkspace(
      name: Swift.String,
    ) async throws -> GoogleCloudDMSV1.ConversionWorkspace

    /// See `DataMigrationServiceClient.listConversionWorkspaces`.
    func listConversionWorkspaces(request: ListConversionWorkspacesRequest) async throws
      -> GoogleCloudDMSV1.ListConversionWorkspacesResponse

    /// See `DataMigrationServiceClient.listConversionWorkspaces`.
    func listConversionWorkspaces(
      byItem: ListConversionWorkspacesRequest
    ) throws -> any AsyncSequence<ConversionWorkspace, Swift.Error>

    /// See `DataMigrationServiceClient.listConversionWorkspaces`.
    func listConversionWorkspaces(
      parent: Swift.String,
    ) throws -> any AsyncSequence<ConversionWorkspace, Swift.Error>

    /// See `DataMigrationServiceClient.createConversionWorkspace`.
    func createConversionWorkspace(request: CreateConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createConversionWorkspace`.
    func createConversionWorkspace(withPolling: CreateConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.createConversionWorkspace`.
    func createConversionWorkspace(
      parent: Swift.String,
      conversionWorkspace: ConversionWorkspace?,
      conversionWorkspaceId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.updateConversionWorkspace`.
    func updateConversionWorkspace(request: UpdateConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.updateConversionWorkspace`.
    func updateConversionWorkspace(withPolling: UpdateConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.updateConversionWorkspace`.
    func updateConversionWorkspace(
      conversionWorkspace: ConversionWorkspace?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.deleteConversionWorkspace`.
    func deleteConversionWorkspace(request: DeleteConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deleteConversionWorkspace`.
    func deleteConversionWorkspace(withPolling: DeleteConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `DataMigrationServiceClient.createMappingRule`.
    func createMappingRule(request: CreateMappingRuleRequest) async throws
      -> GoogleCloudDMSV1.MappingRule

    /// See `DataMigrationServiceClient.createMappingRule`.
    func createMappingRule(
      parent: Swift.String,
      mappingRule: MappingRule?,
      mappingRuleId: Swift.String,
    ) async throws -> GoogleCloudDMSV1.MappingRule

    /// See `DataMigrationServiceClient.deleteMappingRule`.
    func deleteMappingRule(request: DeleteMappingRuleRequest) async throws

    /// See `DataMigrationServiceClient.deleteMappingRule`.
    func deleteMappingRule(
      name: Swift.String,
    ) async throws

    /// See `DataMigrationServiceClient.listMappingRules`.
    func listMappingRules(request: ListMappingRulesRequest) async throws
      -> GoogleCloudDMSV1.ListMappingRulesResponse

    /// See `DataMigrationServiceClient.listMappingRules`.
    func listMappingRules(
      byItem: ListMappingRulesRequest
    ) throws -> any AsyncSequence<MappingRule, Swift.Error>

    /// See `DataMigrationServiceClient.listMappingRules`.
    func listMappingRules(
      parent: Swift.String,
    ) throws -> any AsyncSequence<MappingRule, Swift.Error>

    /// See `DataMigrationServiceClient.getMappingRule`.
    func getMappingRule(request: GetMappingRuleRequest) async throws -> GoogleCloudDMSV1.MappingRule

    /// See `DataMigrationServiceClient.getMappingRule`.
    func getMappingRule(
      name: Swift.String,
    ) async throws -> GoogleCloudDMSV1.MappingRule

    /// See `DataMigrationServiceClient.seedConversionWorkspace`.
    func seedConversionWorkspace(request: SeedConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.seedConversionWorkspace`.
    func seedConversionWorkspace(withPolling: SeedConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.importMappingRules`.
    func importMappingRules(request: ImportMappingRulesRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.importMappingRules`.
    func importMappingRules(withPolling: ImportMappingRulesRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.convertConversionWorkspace`.
    func convertConversionWorkspace(request: ConvertConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.convertConversionWorkspace`.
    func convertConversionWorkspace(withPolling: ConvertConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.commitConversionWorkspace`.
    func commitConversionWorkspace(request: CommitConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.commitConversionWorkspace`.
    func commitConversionWorkspace(withPolling: CommitConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.rollbackConversionWorkspace`.
    func rollbackConversionWorkspace(request: RollbackConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.rollbackConversionWorkspace`.
    func rollbackConversionWorkspace(withPolling: RollbackConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.applyConversionWorkspace`.
    func applyConversionWorkspace(request: ApplyConversionWorkspaceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.applyConversionWorkspace`.
    func applyConversionWorkspace(withPolling: ApplyConversionWorkspaceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.describeDatabaseEntities`.
    func describeDatabaseEntities(request: DescribeDatabaseEntitiesRequest) async throws
      -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse

    /// See `DataMigrationServiceClient.describeDatabaseEntities`.
    func describeDatabaseEntities(
      byItem: DescribeDatabaseEntitiesRequest
    ) throws -> any AsyncSequence<DatabaseEntity, Swift.Error>

    /// See `DataMigrationServiceClient.searchBackgroundJobs`.
    func searchBackgroundJobs(request: SearchBackgroundJobsRequest) async throws
      -> GoogleCloudDMSV1.SearchBackgroundJobsResponse

    /// See `DataMigrationServiceClient.describeConversionWorkspaceRevisions`.
    func describeConversionWorkspaceRevisions(request: DescribeConversionWorkspaceRevisionsRequest)
      async throws -> GoogleCloudDMSV1.DescribeConversionWorkspaceRevisionsResponse

    /// See `DataMigrationServiceClient.fetchStaticIps`.
    func fetchStaticIps(request: FetchStaticIpsRequest) async throws
      -> GoogleCloudDMSV1.FetchStaticIpsResponse

    /// See `DataMigrationServiceClient.fetchStaticIps`.
    func fetchStaticIps(
      name: Swift.String,
    ) async throws -> GoogleCloudDMSV1.FetchStaticIpsResponse

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// See `DataMigrationServiceClient.listMigrationJobs`.
    func listMigrationJobs(
      request: ListMigrationJobsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ListMigrationJobsResponse

    /// See `DataMigrationServiceClient.listMigrationJobs`.
    func listMigrationJobs(
      byItem: ListMigrationJobsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<MigrationJob, Swift.Error>

    /// See `DataMigrationServiceClient.getMigrationJob`.
    func getMigrationJob(
      request: GetMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.MigrationJob

    /// See `DataMigrationServiceClient.createMigrationJob`.
    func createMigrationJob(
      request: CreateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createMigrationJob`.
    func createMigrationJob(
      withPolling: CreateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.updateMigrationJob`.
    func updateMigrationJob(
      request: UpdateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.updateMigrationJob`.
    func updateMigrationJob(
      withPolling: UpdateMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.deleteMigrationJob`.
    func deleteMigrationJob(
      request: DeleteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deleteMigrationJob`.
    func deleteMigrationJob(
      withPolling: DeleteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `DataMigrationServiceClient.startMigrationJob`.
    func startMigrationJob(
      request: StartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.startMigrationJob`.
    func startMigrationJob(
      withPolling: StartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.stopMigrationJob`.
    func stopMigrationJob(
      request: StopMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.stopMigrationJob`.
    func stopMigrationJob(
      withPolling: StopMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.resumeMigrationJob`.
    func resumeMigrationJob(
      request: ResumeMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.resumeMigrationJob`.
    func resumeMigrationJob(
      withPolling: ResumeMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.promoteMigrationJob`.
    func promoteMigrationJob(
      request: PromoteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.promoteMigrationJob`.
    func promoteMigrationJob(
      withPolling: PromoteMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.verifyMigrationJob`.
    func verifyMigrationJob(
      request: VerifyMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.verifyMigrationJob`.
    func verifyMigrationJob(
      withPolling: VerifyMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.restartMigrationJob`.
    func restartMigrationJob(
      request: RestartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.restartMigrationJob`.
    func restartMigrationJob(
      withPolling: RestartMigrationJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob>

    /// See `DataMigrationServiceClient.generateSshScript`.
    func generateSshScript(
      request: GenerateSshScriptRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.SshScript

    /// See `DataMigrationServiceClient.generateTcpProxyScript`.
    func generateTcpProxyScript(
      request: GenerateTcpProxyScriptRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.TcpProxyScript

    /// See `DataMigrationServiceClient.listConnectionProfiles`.
    func listConnectionProfiles(
      request: ListConnectionProfilesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ListConnectionProfilesResponse

    /// See `DataMigrationServiceClient.listConnectionProfiles`.
    func listConnectionProfiles(
      byItem: ListConnectionProfilesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<ConnectionProfile, Swift.Error>

    /// See `DataMigrationServiceClient.getConnectionProfile`.
    func getConnectionProfile(
      request: GetConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ConnectionProfile

    /// See `DataMigrationServiceClient.createConnectionProfile`.
    func createConnectionProfile(
      request: CreateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createConnectionProfile`.
    func createConnectionProfile(
      withPolling: CreateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile>

    /// See `DataMigrationServiceClient.updateConnectionProfile`.
    func updateConnectionProfile(
      request: UpdateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.updateConnectionProfile`.
    func updateConnectionProfile(
      withPolling: UpdateConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile>

    /// See `DataMigrationServiceClient.deleteConnectionProfile`.
    func deleteConnectionProfile(
      request: DeleteConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deleteConnectionProfile`.
    func deleteConnectionProfile(
      withPolling: DeleteConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `DataMigrationServiceClient.createPrivateConnection`.
    func createPrivateConnection(
      request: CreatePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createPrivateConnection`.
    func createPrivateConnection(
      withPolling: CreatePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PrivateConnection>

    /// See `DataMigrationServiceClient.getPrivateConnection`.
    func getPrivateConnection(
      request: GetPrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.PrivateConnection

    /// See `DataMigrationServiceClient.listPrivateConnections`.
    func listPrivateConnections(
      request: ListPrivateConnectionsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ListPrivateConnectionsResponse

    /// See `DataMigrationServiceClient.listPrivateConnections`.
    func listPrivateConnections(
      byItem: ListPrivateConnectionsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<PrivateConnection, Swift.Error>

    /// See `DataMigrationServiceClient.deletePrivateConnection`.
    func deletePrivateConnection(
      request: DeletePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deletePrivateConnection`.
    func deletePrivateConnection(
      withPolling: DeletePrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `DataMigrationServiceClient.getConversionWorkspace`.
    func getConversionWorkspace(
      request: GetConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ConversionWorkspace

    /// See `DataMigrationServiceClient.listConversionWorkspaces`.
    func listConversionWorkspaces(
      request: ListConversionWorkspacesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ListConversionWorkspacesResponse

    /// See `DataMigrationServiceClient.listConversionWorkspaces`.
    func listConversionWorkspaces(
      byItem: ListConversionWorkspacesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<ConversionWorkspace, Swift.Error>

    /// See `DataMigrationServiceClient.createConversionWorkspace`.
    func createConversionWorkspace(
      request: CreateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.createConversionWorkspace`.
    func createConversionWorkspace(
      withPolling: CreateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.updateConversionWorkspace`.
    func updateConversionWorkspace(
      request: UpdateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.updateConversionWorkspace`.
    func updateConversionWorkspace(
      withPolling: UpdateConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.deleteConversionWorkspace`.
    func deleteConversionWorkspace(
      request: DeleteConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.deleteConversionWorkspace`.
    func deleteConversionWorkspace(
      withPolling: DeleteConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `DataMigrationServiceClient.createMappingRule`.
    func createMappingRule(
      request: CreateMappingRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.MappingRule

    /// See `DataMigrationServiceClient.deleteMappingRule`.
    func deleteMappingRule(
      request: DeleteMappingRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws

    /// See `DataMigrationServiceClient.listMappingRules`.
    func listMappingRules(
      request: ListMappingRulesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.ListMappingRulesResponse

    /// See `DataMigrationServiceClient.listMappingRules`.
    func listMappingRules(
      byItem: ListMappingRulesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<MappingRule, Swift.Error>

    /// See `DataMigrationServiceClient.getMappingRule`.
    func getMappingRule(
      request: GetMappingRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.MappingRule

    /// See `DataMigrationServiceClient.seedConversionWorkspace`.
    func seedConversionWorkspace(
      request: SeedConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.seedConversionWorkspace`.
    func seedConversionWorkspace(
      withPolling: SeedConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.importMappingRules`.
    func importMappingRules(
      request: ImportMappingRulesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.importMappingRules`.
    func importMappingRules(
      withPolling: ImportMappingRulesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.convertConversionWorkspace`.
    func convertConversionWorkspace(
      request: ConvertConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.convertConversionWorkspace`.
    func convertConversionWorkspace(
      withPolling: ConvertConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.commitConversionWorkspace`.
    func commitConversionWorkspace(
      request: CommitConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.commitConversionWorkspace`.
    func commitConversionWorkspace(
      withPolling: CommitConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.rollbackConversionWorkspace`.
    func rollbackConversionWorkspace(
      request: RollbackConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.rollbackConversionWorkspace`.
    func rollbackConversionWorkspace(
      withPolling: RollbackConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.applyConversionWorkspace`.
    func applyConversionWorkspace(
      request: ApplyConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `DataMigrationServiceClient.applyConversionWorkspace`.
    func applyConversionWorkspace(
      withPolling: ApplyConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>

    /// See `DataMigrationServiceClient.describeDatabaseEntities`.
    func describeDatabaseEntities(
      request: DescribeDatabaseEntitiesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse

    /// See `DataMigrationServiceClient.describeDatabaseEntities`.
    func describeDatabaseEntities(
      byItem: DescribeDatabaseEntitiesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<DatabaseEntity, Swift.Error>

    /// See `DataMigrationServiceClient.searchBackgroundJobs`.
    func searchBackgroundJobs(
      request: SearchBackgroundJobsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.SearchBackgroundJobsResponse

    /// See `DataMigrationServiceClient.describeConversionWorkspaceRevisions`.
    func describeConversionWorkspaceRevisions(
      request: DescribeConversionWorkspaceRevisionsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.DescribeConversionWorkspaceRevisionsResponse

    /// See `DataMigrationServiceClient.fetchStaticIps`.
    func fetchStaticIps(
      request: FetchStaticIpsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDMSV1.FetchStaticIpsResponse

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

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

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

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

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

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

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

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

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

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

// Default implementations
extension Clients.DataMigrationServiceProtocol {
  public func listMigrationJobs(request: ListMigrationJobsRequest) async throws
    -> GoogleCloudDMSV1.ListMigrationJobsResponse
  {
    try await self.listMigrationJobs(request: request, options: .init())
  }

  public func listMigrationJobs(
    request: ListMigrationJobsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListMigrationJobsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listMigrationJobs(
    byItem: ListMigrationJobsRequest
  ) throws -> any AsyncSequence<MigrationJob, Swift.Error> {
    try self.listMigrationJobs(byItem: byItem, options: .init())
  }

  public func listMigrationJobs(
    byItem: ListMigrationJobsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MigrationJob, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListMigrationJobsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getMigrationJob(request: GetMigrationJobRequest) async throws
    -> GoogleCloudDMSV1.MigrationJob
  {
    try await self.getMigrationJob(request: request, options: .init())
  }

  public func getMigrationJob(
    request: GetMigrationJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.MigrationJob {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getMigrationJob(
    name: Swift.String,
  ) async throws -> GoogleCloudDMSV1.MigrationJob {
    let request = GetMigrationJobRequest().with {
      $0.name = name
    }
    return try await self.getMigrationJob(request: request)
  }

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

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

  public func createMigrationJob(withPolling: CreateMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.createMigrationJob(withPolling: withPolling, options: .init())
  }

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

  public func createMigrationJob(
    parent: Swift.String,
    migrationJob: MigrationJob?,
    migrationJobId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<MigrationJob> {
    let request = CreateMigrationJobRequest().with {
      $0.parent = parent
      $0.migrationJob = migrationJob
      $0.migrationJobId = migrationJobId
    }
    return try await self.createMigrationJob(withPolling: request)
  }

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

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

  public func updateMigrationJob(withPolling: UpdateMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.updateMigrationJob(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

  public func deleteMigrationJob(
    withPolling: DeleteMigrationJobRequest, 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 deleteMigrationJob(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteMigrationJobRequest().with {
      $0.name = name
    }
    return try await self.deleteMigrationJob(withPolling: request)
  }

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

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

  public func startMigrationJob(withPolling: StartMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.startMigrationJob(withPolling: withPolling, options: .init())
  }

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

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

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

  public func stopMigrationJob(withPolling: StopMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.stopMigrationJob(withPolling: withPolling, options: .init())
  }

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

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

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

  public func resumeMigrationJob(withPolling: ResumeMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.resumeMigrationJob(withPolling: withPolling, options: .init())
  }

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

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

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

  public func promoteMigrationJob(withPolling: PromoteMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.promoteMigrationJob(withPolling: withPolling, options: .init())
  }

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

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

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

  public func verifyMigrationJob(withPolling: VerifyMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.verifyMigrationJob(withPolling: withPolling, options: .init())
  }

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

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

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

  public func restartMigrationJob(withPolling: RestartMigrationJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MigrationJob>
  {
    try await self.restartMigrationJob(withPolling: withPolling, options: .init())
  }

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

  public func generateSshScript(request: GenerateSshScriptRequest) async throws
    -> GoogleCloudDMSV1.SshScript
  {
    try await self.generateSshScript(request: request, options: .init())
  }

  public func generateSshScript(
    request: GenerateSshScriptRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.SshScript {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func generateTcpProxyScript(request: GenerateTcpProxyScriptRequest) async throws
    -> GoogleCloudDMSV1.TcpProxyScript
  {
    try await self.generateTcpProxyScript(request: request, options: .init())
  }

  public func generateTcpProxyScript(
    request: GenerateTcpProxyScriptRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.TcpProxyScript {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listConnectionProfiles(request: ListConnectionProfilesRequest) async throws
    -> GoogleCloudDMSV1.ListConnectionProfilesResponse
  {
    try await self.listConnectionProfiles(request: request, options: .init())
  }

  public func listConnectionProfiles(
    request: ListConnectionProfilesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListConnectionProfilesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listConnectionProfiles(
    byItem: ListConnectionProfilesRequest
  ) throws -> any AsyncSequence<ConnectionProfile, Swift.Error> {
    try self.listConnectionProfiles(byItem: byItem, options: .init())
  }

  public func listConnectionProfiles(
    byItem: ListConnectionProfilesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<ConnectionProfile, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListConnectionProfilesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getConnectionProfile(request: GetConnectionProfileRequest) async throws
    -> GoogleCloudDMSV1.ConnectionProfile
  {
    try await self.getConnectionProfile(request: request, options: .init())
  }

  public func getConnectionProfile(
    request: GetConnectionProfileRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ConnectionProfile {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getConnectionProfile(
    name: Swift.String,
  ) async throws -> GoogleCloudDMSV1.ConnectionProfile {
    let request = GetConnectionProfileRequest().with {
      $0.name = name
    }
    return try await self.getConnectionProfile(request: request)
  }

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

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

  public func createConnectionProfile(withPolling: CreateConnectionProfileRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConnectionProfile>
  {
    try await self.createConnectionProfile(withPolling: withPolling, options: .init())
  }

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

  public func createConnectionProfile(
    parent: Swift.String,
    connectionProfile: ConnectionProfile?,
    connectionProfileId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<ConnectionProfile> {
    let request = CreateConnectionProfileRequest().with {
      $0.parent = parent
      $0.connectionProfile = connectionProfile
      $0.connectionProfileId = connectionProfileId
    }
    return try await self.createConnectionProfile(withPolling: request)
  }

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

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

  public func updateConnectionProfile(withPolling: UpdateConnectionProfileRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConnectionProfile>
  {
    try await self.updateConnectionProfile(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

  public func deleteConnectionProfile(
    withPolling: DeleteConnectionProfileRequest, 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 deleteConnectionProfile(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteConnectionProfileRequest().with {
      $0.name = name
    }
    return try await self.deleteConnectionProfile(withPolling: request)
  }

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

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

  public func createPrivateConnection(withPolling: CreatePrivateConnectionRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PrivateConnection>
  {
    try await self.createPrivateConnection(withPolling: withPolling, options: .init())
  }

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

  public func createPrivateConnection(
    parent: Swift.String,
    privateConnection: PrivateConnection?,
    privateConnectionId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<PrivateConnection> {
    let request = CreatePrivateConnectionRequest().with {
      $0.parent = parent
      $0.privateConnection = privateConnection
      $0.privateConnectionId = privateConnectionId
    }
    return try await self.createPrivateConnection(withPolling: request)
  }

  public func getPrivateConnection(request: GetPrivateConnectionRequest) async throws
    -> GoogleCloudDMSV1.PrivateConnection
  {
    try await self.getPrivateConnection(request: request, options: .init())
  }

  public func getPrivateConnection(
    request: GetPrivateConnectionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.PrivateConnection {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getPrivateConnection(
    name: Swift.String,
  ) async throws -> GoogleCloudDMSV1.PrivateConnection {
    let request = GetPrivateConnectionRequest().with {
      $0.name = name
    }
    return try await self.getPrivateConnection(request: request)
  }

  public func listPrivateConnections(request: ListPrivateConnectionsRequest) async throws
    -> GoogleCloudDMSV1.ListPrivateConnectionsResponse
  {
    try await self.listPrivateConnections(request: request, options: .init())
  }

  public func listPrivateConnections(
    request: ListPrivateConnectionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListPrivateConnectionsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listPrivateConnections(
    byItem: ListPrivateConnectionsRequest
  ) throws -> any AsyncSequence<PrivateConnection, Swift.Error> {
    try self.listPrivateConnections(byItem: byItem, options: .init())
  }

  public func listPrivateConnections(
    byItem: ListPrivateConnectionsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<PrivateConnection, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListPrivateConnectionsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

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

  public func deletePrivateConnection(
    withPolling: DeletePrivateConnectionRequest, 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 deletePrivateConnection(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeletePrivateConnectionRequest().with {
      $0.name = name
    }
    return try await self.deletePrivateConnection(withPolling: request)
  }

  public func getConversionWorkspace(request: GetConversionWorkspaceRequest) async throws
    -> GoogleCloudDMSV1.ConversionWorkspace
  {
    try await self.getConversionWorkspace(request: request, options: .init())
  }

  public func getConversionWorkspace(
    request: GetConversionWorkspaceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ConversionWorkspace {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getConversionWorkspace(
    name: Swift.String,
  ) async throws -> GoogleCloudDMSV1.ConversionWorkspace {
    let request = GetConversionWorkspaceRequest().with {
      $0.name = name
    }
    return try await self.getConversionWorkspace(request: request)
  }

  public func listConversionWorkspaces(request: ListConversionWorkspacesRequest) async throws
    -> GoogleCloudDMSV1.ListConversionWorkspacesResponse
  {
    try await self.listConversionWorkspaces(request: request, options: .init())
  }

  public func listConversionWorkspaces(
    request: ListConversionWorkspacesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListConversionWorkspacesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listConversionWorkspaces(
    byItem: ListConversionWorkspacesRequest
  ) throws -> any AsyncSequence<ConversionWorkspace, Swift.Error> {
    try self.listConversionWorkspaces(byItem: byItem, options: .init())
  }

  public func listConversionWorkspaces(
    byItem: ListConversionWorkspacesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<ConversionWorkspace, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListConversionWorkspacesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

  public func createConversionWorkspace(withPolling: CreateConversionWorkspaceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.createConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

  public func createConversionWorkspace(
    parent: Swift.String,
    conversionWorkspace: ConversionWorkspace?,
    conversionWorkspaceId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace> {
    let request = CreateConversionWorkspaceRequest().with {
      $0.parent = parent
      $0.conversionWorkspace = conversionWorkspace
      $0.conversionWorkspaceId = conversionWorkspaceId
    }
    return try await self.createConversionWorkspace(withPolling: request)
  }

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

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

  public func updateConversionWorkspace(withPolling: UpdateConversionWorkspaceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.updateConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

  public func deleteConversionWorkspace(
    withPolling: DeleteConversionWorkspaceRequest, 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 deleteConversionWorkspace(
    name: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Void> {
    let request = DeleteConversionWorkspaceRequest().with {
      $0.name = name
    }
    return try await self.deleteConversionWorkspace(withPolling: request)
  }

  public func createMappingRule(request: CreateMappingRuleRequest) async throws
    -> GoogleCloudDMSV1.MappingRule
  {
    try await self.createMappingRule(request: request, options: .init())
  }

  public func createMappingRule(
    request: CreateMappingRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.MappingRule {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createMappingRule(
    parent: Swift.String,
    mappingRule: MappingRule?,
    mappingRuleId: Swift.String,
  ) async throws -> GoogleCloudDMSV1.MappingRule {
    let request = CreateMappingRuleRequest().with {
      $0.parent = parent
      $0.mappingRule = mappingRule
      $0.mappingRuleId = mappingRuleId
    }
    return try await self.createMappingRule(request: request)
  }

  public func deleteMappingRule(request: DeleteMappingRuleRequest) async throws {
    try await self.deleteMappingRule(request: request, options: .init())
  }

  public func deleteMappingRule(
    request: DeleteMappingRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    throw GoogleCloudGax.RequestError.unimplemented
  }

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

  public func listMappingRules(request: ListMappingRulesRequest) async throws
    -> GoogleCloudDMSV1.ListMappingRulesResponse
  {
    try await self.listMappingRules(request: request, options: .init())
  }

  public func listMappingRules(
    request: ListMappingRulesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.ListMappingRulesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listMappingRules(
    byItem: ListMappingRulesRequest
  ) throws -> any AsyncSequence<MappingRule, Swift.Error> {
    try self.listMappingRules(byItem: byItem, options: .init())
  }

  public func listMappingRules(
    byItem: ListMappingRulesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MappingRule, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.ListMappingRulesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getMappingRule(request: GetMappingRuleRequest) async throws
    -> GoogleCloudDMSV1.MappingRule
  {
    try await self.getMappingRule(request: request, options: .init())
  }

  public func getMappingRule(
    request: GetMappingRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.MappingRule {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getMappingRule(
    name: Swift.String,
  ) async throws -> GoogleCloudDMSV1.MappingRule {
    let request = GetMappingRuleRequest().with {
      $0.name = name
    }
    return try await self.getMappingRule(request: request)
  }

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

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

  public func seedConversionWorkspace(withPolling: SeedConversionWorkspaceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.seedConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

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

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

  public func importMappingRules(withPolling: ImportMappingRulesRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.importMappingRules(withPolling: withPolling, options: .init())
  }

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

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

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

  public func convertConversionWorkspace(withPolling: ConvertConversionWorkspaceRequest)
    async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.convertConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

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

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

  public func commitConversionWorkspace(withPolling: CommitConversionWorkspaceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.commitConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

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

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

  public func rollbackConversionWorkspace(withPolling: RollbackConversionWorkspaceRequest)
    async throws -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.rollbackConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

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

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

  public func applyConversionWorkspace(withPolling: ApplyConversionWorkspaceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<ConversionWorkspace>
  {
    try await self.applyConversionWorkspace(withPolling: withPolling, options: .init())
  }

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

  public func describeDatabaseEntities(request: DescribeDatabaseEntitiesRequest) async throws
    -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse
  {
    try await self.describeDatabaseEntities(request: request, options: .init())
  }

  public func describeDatabaseEntities(
    request: DescribeDatabaseEntitiesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func describeDatabaseEntities(
    byItem: DescribeDatabaseEntitiesRequest
  ) throws -> any AsyncSequence<DatabaseEntity, Swift.Error> {
    try self.describeDatabaseEntities(byItem: byItem, options: .init())
  }

  public func describeDatabaseEntities(
    byItem: DescribeDatabaseEntitiesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<DatabaseEntity, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDMSV1.DescribeDatabaseEntitiesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func searchBackgroundJobs(request: SearchBackgroundJobsRequest) async throws
    -> GoogleCloudDMSV1.SearchBackgroundJobsResponse
  {
    try await self.searchBackgroundJobs(request: request, options: .init())
  }

  public func searchBackgroundJobs(
    request: SearchBackgroundJobsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.SearchBackgroundJobsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func describeConversionWorkspaceRevisions(
    request: DescribeConversionWorkspaceRevisionsRequest
  ) async throws -> GoogleCloudDMSV1.DescribeConversionWorkspaceRevisionsResponse {
    try await self.describeConversionWorkspaceRevisions(request: request, options: .init())
  }

  public func describeConversionWorkspaceRevisions(
    request: DescribeConversionWorkspaceRevisionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.DescribeConversionWorkspaceRevisionsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func fetchStaticIps(request: FetchStaticIpsRequest) async throws
    -> GoogleCloudDMSV1.FetchStaticIpsResponse
  {
    try await self.fetchStaticIps(request: request, options: .init())
  }

  public func fetchStaticIps(
    request: FetchStaticIpsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDMSV1.FetchStaticIpsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func fetchStaticIps(
    name: Swift.String,
  ) async throws -> GoogleCloudDMSV1.FetchStaticIpsResponse {
    let request = FetchStaticIpsRequest().with {
      $0.name = name
    }
    return try await self.fetchStaticIps(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)
  }
}
