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

/// Secure Source Manager API
///
/// Access Secure Source Manager instances, resources, and repositories.
///
/// @Snippet(path: "SecureSourceManagerQuickstart")
public class SecureSourceManagerClient: Clients.SecureSourceManagerProtocol {
  let inner: any Clients.SecureSourceManagerStub
  let pollingErrorPolicy: GoogleCloudGax.PollingErrorPolicy
  let pollingBackoffPolicy: GoogleCloudGax.BackoffPolicy

  /// Creates a new `SecureSourceManagerClient` instance.
  public init(_ options: GoogleCloudGax.ClientOptions = .init()) throws {
    var inner: any Clients.SecureSourceManagerStub = try Clients.SecureSourceManagerTransport(
      options)
    inner = Clients.SecureSourceManagerRetry(inner, options: options)
    if let logger = options.logger {
      inner = Clients.SecureSourceManagerLogging(inner, logger: logger)
    }
    self.inner = inner
    self.pollingErrorPolicy = options.pollingErrorPolicy
    self.pollingBackoffPolicy = options.pollingBackoffPolicy
  }

  /// Lists Instances in a given project and location.
  ///
  /// @Snippet(path: "SecureSourceManager_ListInstances")
  public func listInstances(
    request: ListInstancesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse {
    try await self.inner.listInstances(request: request, options: options)
  }

  /// Lists Instances in a given project and location.
  ///
  /// @Snippet(path: "SecureSourceManager_ListInstances")
  public func listInstances(
    byItem: ListInstancesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Instance, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse
      in
      var request = byItem
      request.pageToken = token
      return try await self.listInstances(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets details of a single instance.
  ///
  /// @Snippet(path: "SecureSourceManager_GetInstance")
  public func getInstance(
    request: GetInstanceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Instance {
    try await self.inner.getInstance(request: request, options: options)
  }

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

  /// Creates a new instance in a given project and location.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateInstance")
  public func createInstance(
    withPolling: CreateInstanceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Instance> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Instance>.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 Instance(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.createInstance(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Instance>.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 instance.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteInstance")
  public func deleteInstance(
    request: DeleteInstanceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteInstance(request: request, options: options)
  }

  /// Deletes a single instance.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteInstance")
  public func deleteInstance(
    withPolling: DeleteInstanceRequest, 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.deleteInstance(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists Repositories in a given project and location.
  ///
  /// The instance field is required in the query parameter for requests using
  /// the securesourcemanager.googleapis.com endpoint.
  ///
  /// @Snippet(path: "SecureSourceManager_ListRepositories")
  public func listRepositories(
    request: ListRepositoriesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse {
    try await self.inner.listRepositories(request: request, options: options)
  }

  /// Lists Repositories in a given project and location.
  ///
  /// The instance field is required in the query parameter for requests using
  /// the securesourcemanager.googleapis.com endpoint.
  ///
  /// @Snippet(path: "SecureSourceManager_ListRepositories")
  public func listRepositories(
    byItem: ListRepositoriesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Repository, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listRepositories(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets metadata of a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_GetRepository")
  public func getRepository(
    request: GetRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Repository {
    try await self.inner.getRepository(request: request, options: options)
  }

  /// Creates a new repository in a given project and location.
  ///
  /// The Repository.Instance field is required in the request body for requests
  /// using the securesourcemanager.googleapis.com endpoint.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateRepository")
  public func createRepository(
    request: CreateRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createRepository(request: request, options: options)
  }

  /// Creates a new repository in a given project and location.
  ///
  /// The Repository.Instance field is required in the request body for requests
  /// using the securesourcemanager.googleapis.com endpoint.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateRepository")
  public func createRepository(
    withPolling: CreateRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Repository> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Repository>.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 Repository(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.createRepository(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Repository>.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 metadata of a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateRepository")
  public func updateRepository(
    request: UpdateRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateRepository(request: request, options: options)
  }

  /// Updates the metadata of a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateRepository")
  public func updateRepository(
    withPolling: UpdateRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Repository> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<Repository>.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 Repository(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.updateRepository(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Repository>.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 Repository.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteRepository")
  public func deleteRepository(
    request: DeleteRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteRepository(request: request, options: options)
  }

  /// Deletes a Repository.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteRepository")
  public func deleteRepository(
    withPolling: DeleteRepositoryRequest, 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.deleteRepository(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists hooks in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListHooks")
  public func listHooks(
    request: ListHooksRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListHooksResponse {
    try await self.inner.listHooks(request: request, options: options)
  }

  /// Lists hooks in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListHooks")
  public func listHooks(
    byItem: ListHooksRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Hook, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListHooksResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listHooks(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets metadata of a hook.
  ///
  /// @Snippet(path: "SecureSourceManager_GetHook")
  public func getHook(
    request: GetHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Hook {
    try await self.inner.getHook(request: request, options: options)
  }

  /// Creates a new hook in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateHook")
  public func createHook(
    request: CreateHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createHook(request: request, options: options)
  }

  /// Creates a new hook in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateHook")
  public func createHook(
    withPolling: CreateHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Hook> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Hook>.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 Hook(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.createHook(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Hook>.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 metadata of a hook.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateHook")
  public func updateHook(
    request: UpdateHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateHook(request: request, options: options)
  }

  /// Updates the metadata of a hook.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateHook")
  public func updateHook(
    withPolling: UpdateHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Hook> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Hook>.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 Hook(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.updateHook(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Hook>.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 Hook.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteHook")
  public func deleteHook(
    request: DeleteHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteHook(request: request, options: options)
  }

  /// Deletes a Hook.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteHook")
  public func deleteHook(
    withPolling: DeleteHookRequest, 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.deleteHook(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,
    )
  }

  /// Get IAM policy for a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_GetIamPolicyRepo")
  public func getIamPolicyRepo(
    request: GoogleIAMV1.GetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.Policy {
    try await self.inner.getIamPolicyRepo(request: request, options: options)
  }

  /// Set IAM policy on a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_SetIamPolicyRepo")
  public func setIamPolicyRepo(
    request: GoogleIAMV1.SetIamPolicyRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.Policy {
    try await self.inner.setIamPolicyRepo(request: request, options: options)
  }

  /// Test IAM permissions on a repository.
  /// IAM permission checks are not required on this method.
  ///
  /// @Snippet(path: "SecureSourceManager_TestIamPermissionsRepo")
  public func testIamPermissionsRepo(
    request: GoogleIAMV1.TestIamPermissionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleIAMV1.TestIamPermissionsResponse {
    try await self.inner.testIamPermissionsRepo(request: request, options: options)
  }

  /// CreateBranchRule creates a branch rule in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateBranchRule")
  public func createBranchRule(
    request: CreateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createBranchRule(request: request, options: options)
  }

  /// CreateBranchRule creates a branch rule in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateBranchRule")
  public func createBranchRule(
    withPolling: CreateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BranchRule>.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 BranchRule(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.createBranchRule(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BranchRule>.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,
    )
  }

  /// ListBranchRules lists branch rules in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListBranchRules")
  public func listBranchRules(
    request: ListBranchRulesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse {
    try await self.inner.listBranchRules(request: request, options: options)
  }

  /// ListBranchRules lists branch rules in a given repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListBranchRules")
  public func listBranchRules(
    byItem: ListBranchRulesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BranchRule, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse
      in
      var request = byItem
      request.pageToken = token
      return try await self.listBranchRules(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// GetBranchRule gets a branch rule.
  ///
  /// @Snippet(path: "SecureSourceManager_GetBranchRule")
  public func getBranchRule(
    request: GetBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.BranchRule {
    try await self.inner.getBranchRule(request: request, options: options)
  }

  /// UpdateBranchRule updates a branch rule.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateBranchRule")
  public func updateBranchRule(
    request: UpdateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateBranchRule(request: request, options: options)
  }

  /// UpdateBranchRule updates a branch rule.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateBranchRule")
  public func updateBranchRule(
    withPolling: UpdateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BranchRule>.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 BranchRule(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.updateBranchRule(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<BranchRule>.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,
    )
  }

  /// DeleteBranchRule deletes a branch rule.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteBranchRule")
  public func deleteBranchRule(
    request: DeleteBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteBranchRule(request: request, options: options)
  }

  /// DeleteBranchRule deletes a branch rule.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteBranchRule")
  public func deleteBranchRule(
    withPolling: DeleteBranchRuleRequest, 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.deleteBranchRule(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 pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_CreatePullRequest")
  public func createPullRequest(
    request: CreatePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createPullRequest(request: request, options: options)
  }

  /// Creates a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_CreatePullRequest")
  public func createPullRequest(
    withPolling: CreatePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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 PullRequest(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.createPullRequest(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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 a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_GetPullRequest")
  public func getPullRequest(
    request: GetPullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequest {
    try await self.inner.getPullRequest(request: request, options: options)
  }

  /// Lists pull requests in a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListPullRequests")
  public func listPullRequests(
    request: ListPullRequestsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse {
    try await self.inner.listPullRequests(request: request, options: options)
  }

  /// Lists pull requests in a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListPullRequests")
  public func listPullRequests(
    byItem: ListPullRequestsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<PullRequest, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listPullRequests(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Updates a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdatePullRequest")
  public func updatePullRequest(
    request: UpdatePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updatePullRequest(request: request, options: options)
  }

  /// Updates a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdatePullRequest")
  public func updatePullRequest(
    withPolling: UpdatePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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 PullRequest(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.updatePullRequest(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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,
    )
  }

  /// Merges a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_MergePullRequest")
  public func mergePullRequest(
    request: MergePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.mergePullRequest(request: request, options: options)
  }

  /// Merges a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_MergePullRequest")
  public func mergePullRequest(
    withPolling: MergePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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 PullRequest(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.mergePullRequest(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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,
    )
  }

  /// Opens a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_OpenPullRequest")
  public func openPullRequest(
    request: OpenPullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.openPullRequest(request: request, options: options)
  }

  /// Opens a pull request.
  ///
  /// @Snippet(path: "SecureSourceManager_OpenPullRequest")
  public func openPullRequest(
    withPolling: OpenPullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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 PullRequest(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.openPullRequest(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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,
    )
  }

  /// Closes a pull request without merging.
  ///
  /// @Snippet(path: "SecureSourceManager_ClosePullRequest")
  public func closePullRequest(
    request: ClosePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.closePullRequest(request: request, options: options)
  }

  /// Closes a pull request without merging.
  ///
  /// @Snippet(path: "SecureSourceManager_ClosePullRequest")
  public func closePullRequest(
    withPolling: ClosePullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequest>.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 PullRequest(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.closePullRequest(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequest>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists a pull request's file diffs.
  ///
  /// @Snippet(path: "SecureSourceManager_ListPullRequestFileDiffs")
  public func listPullRequestFileDiffs(
    request: ListPullRequestFileDiffsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse {
    try await self.inner.listPullRequestFileDiffs(request: request, options: options)
  }

  /// Lists a pull request's file diffs.
  ///
  /// @Snippet(path: "SecureSourceManager_ListPullRequestFileDiffs")
  public func listPullRequestFileDiffs(
    byItem: ListPullRequestFileDiffsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<FileDiff, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listPullRequestFileDiffs(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Fetches a tree from a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_FetchTree")
  public func fetchTree(
    request: FetchTreeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse {
    try await self.inner.fetchTree(request: request, options: options)
  }

  /// Fetches a tree from a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_FetchTree")
  public func fetchTree(
    byItem: FetchTreeRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<TreeEntry, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse in
      var request = byItem
      request.pageToken = token
      return try await self.fetchTree(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Fetches a blob from a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_FetchBlob")
  public func fetchBlob(
    request: FetchBlobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.FetchBlobResponse {
    try await self.inner.fetchBlob(request: request, options: options)
  }

  /// Creates an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateIssue")
  public func createIssue(
    request: CreateIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createIssue(request: request, options: options)
  }

  /// Creates an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateIssue")
  public func createIssue(
    withPolling: CreateIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Issue> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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 Issue(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.createIssue(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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 an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_GetIssue")
  public func getIssue(
    request: GetIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Issue {
    try await self.inner.getIssue(request: request, options: options)
  }

  /// Lists issues in a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListIssues")
  public func listIssues(
    request: ListIssuesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse {
    try await self.inner.listIssues(request: request, options: options)
  }

  /// Lists issues in a repository.
  ///
  /// @Snippet(path: "SecureSourceManager_ListIssues")
  public func listIssues(
    byItem: ListIssuesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Issue, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listIssues(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Updates a issue.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateIssue")
  public func updateIssue(
    request: UpdateIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateIssue(request: request, options: options)
  }

  /// Updates a issue.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateIssue")
  public func updateIssue(
    withPolling: UpdateIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Issue> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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 Issue(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.updateIssue(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Issue>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteIssue")
  public func deleteIssue(
    request: DeleteIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteIssue(request: request, options: options)
  }

  /// Deletes an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteIssue")
  public func deleteIssue(
    withPolling: DeleteIssueRequest, 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.deleteIssue(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,
    )
  }

  /// Opens an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_OpenIssue")
  public func openIssue(
    request: OpenIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.openIssue(request: request, options: options)
  }

  /// Opens an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_OpenIssue")
  public func openIssue(
    withPolling: OpenIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Issue> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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 Issue(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.openIssue(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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,
    )
  }

  /// Closes an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_CloseIssue")
  public func closeIssue(
    request: CloseIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.closeIssue(request: request, options: options)
  }

  /// Closes an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_CloseIssue")
  public func closeIssue(
    withPolling: CloseIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Issue> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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 Issue(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.closeIssue(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Issue>.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 a pull request comment.
  ///
  /// @Snippet(path: "SecureSourceManager_GetPullRequestComment")
  public func getPullRequestComment(
    request: GetPullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequestComment {
    try await self.inner.getPullRequestComment(request: request, options: options)
  }

  /// Lists pull request comments.
  ///
  /// @Snippet(path: "SecureSourceManager_ListPullRequestComments")
  public func listPullRequestComments(
    request: ListPullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse {
    try await self.inner.listPullRequestComments(request: request, options: options)
  }

  /// Lists pull request comments.
  ///
  /// @Snippet(path: "SecureSourceManager_ListPullRequestComments")
  public func listPullRequestComments(
    byItem: ListPullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<PullRequestComment, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listPullRequestComments(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Creates a pull request comment. This function is used to create a single
  /// PullRequestComment of type Comment, or a single PullRequestComment of type
  /// Code that's replying to another PullRequestComment of type Code. Use
  /// BatchCreatePullRequestComments to create multiple PullRequestComments for
  /// code reviews.
  ///
  /// @Snippet(path: "SecureSourceManager_CreatePullRequestComment")
  public func createPullRequestComment(
    request: CreatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createPullRequestComment(request: request, options: options)
  }

  /// Creates a pull request comment. This function is used to create a single
  /// PullRequestComment of type Comment, or a single PullRequestComment of type
  /// Code that's replying to another PullRequestComment of type Code. Use
  /// BatchCreatePullRequestComments to create multiple PullRequestComments for
  /// code reviews.
  ///
  /// @Snippet(path: "SecureSourceManager_CreatePullRequestComment")
  public func createPullRequestComment(
    withPolling: CreatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequestComment>.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 PullRequestComment(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.createPullRequestComment(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequestComment>.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 a pull request comment.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdatePullRequestComment")
  public func updatePullRequestComment(
    request: UpdatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updatePullRequestComment(request: request, options: options)
  }

  /// Updates a pull request comment.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdatePullRequestComment")
  public func updatePullRequestComment(
    withPolling: UpdatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<PullRequestComment>.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 PullRequestComment(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.updatePullRequestComment(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws -> GoogleCloudGax._PollableOperationImpl<PullRequestComment>.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 pull request comment.
  ///
  /// @Snippet(path: "SecureSourceManager_DeletePullRequestComment")
  public func deletePullRequestComment(
    request: DeletePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deletePullRequestComment(request: request, options: options)
  }

  /// Deletes a pull request comment.
  ///
  /// @Snippet(path: "SecureSourceManager_DeletePullRequestComment")
  public func deletePullRequestComment(
    withPolling: DeletePullRequestCommentRequest, 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.deletePullRequestComment(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,
    )
  }

  /// Batch creates pull request comments. This function is used to create
  /// multiple PullRequestComments for code review. There needs to be exactly one
  /// PullRequestComment of type Review, and at most 100 PullRequestComments of
  /// type Code per request. The Position of the code comments must be unique
  /// within the request.
  ///
  /// @Snippet(path: "SecureSourceManager_BatchCreatePullRequestComments")
  public func batchCreatePullRequestComments(
    request: BatchCreatePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.batchCreatePullRequestComments(request: request, options: options)
  }

  /// Batch creates pull request comments. This function is used to create
  /// multiple PullRequestComments for code review. There needs to be exactly one
  /// PullRequestComment of type Review, and at most 100 PullRequestComments of
  /// type Code per request. The Position of the code comments must be unique
  /// within the request.
  ///
  /// @Snippet(path: "SecureSourceManager_BatchCreatePullRequestComments")
  public func batchCreatePullRequestComments(
    withPolling: BatchCreatePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<BatchCreatePullRequestCommentsResponse> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<BatchCreatePullRequestCommentsResponse>.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 BatchCreatePullRequestCommentsResponse(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.batchCreatePullRequestComments(
      request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws
        -> GoogleCloudGax._PollableOperationImpl<BatchCreatePullRequestCommentsResponse>.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,
    )
  }

  /// Resolves pull request comments. A list of PullRequestComment names must be
  /// provided. The PullRequestComment names must be in the same conversation
  /// thread. If auto_fill is set, all comments in the conversation thread will
  /// be resolved.
  ///
  /// @Snippet(path: "SecureSourceManager_ResolvePullRequestComments")
  public func resolvePullRequestComments(
    request: ResolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.resolvePullRequestComments(request: request, options: options)
  }

  /// Resolves pull request comments. A list of PullRequestComment names must be
  /// provided. The PullRequestComment names must be in the same conversation
  /// thread. If auto_fill is set, all comments in the conversation thread will
  /// be resolved.
  ///
  /// @Snippet(path: "SecureSourceManager_ResolvePullRequestComments")
  public func resolvePullRequestComments(
    withPolling: ResolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<ResolvePullRequestCommentsResponse> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<ResolvePullRequestCommentsResponse>.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 ResolvePullRequestCommentsResponse(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.resolvePullRequestComments(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws
        -> GoogleCloudGax._PollableOperationImpl<ResolvePullRequestCommentsResponse>.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,
    )
  }

  /// Unresolves pull request comments. A list of PullRequestComment names must
  /// be provided. The PullRequestComment names must be in the same conversation
  /// thread. If auto_fill is set, all comments in the conversation thread will
  /// be unresolved.
  ///
  /// @Snippet(path: "SecureSourceManager_UnresolvePullRequestComments")
  public func unresolvePullRequestComments(
    request: UnresolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.unresolvePullRequestComments(request: request, options: options)
  }

  /// Unresolves pull request comments. A list of PullRequestComment names must
  /// be provided. The PullRequestComment names must be in the same conversation
  /// thread. If auto_fill is set, all comments in the conversation thread will
  /// be unresolved.
  ///
  /// @Snippet(path: "SecureSourceManager_UnresolvePullRequestComments")
  public func unresolvePullRequestComments(
    withPolling: UnresolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<UnresolvePullRequestCommentsResponse> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<UnresolvePullRequestCommentsResponse>.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 UnresolvePullRequestCommentsResponse(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.unresolvePullRequestComments(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = {
      () async throws
        -> GoogleCloudGax._PollableOperationImpl<UnresolvePullRequestCommentsResponse>.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 an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateIssueComment")
  public func createIssueComment(
    request: CreateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createIssueComment(request: request, options: options)
  }

  /// Creates an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_CreateIssueComment")
  public func createIssueComment(
    withPolling: CreateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<IssueComment>.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 IssueComment(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.createIssueComment(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<IssueComment>.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 an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_GetIssueComment")
  public func getIssueComment(
    request: GetIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.IssueComment {
    try await self.inner.getIssueComment(request: request, options: options)
  }

  /// Lists comments in an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_ListIssueComments")
  public func listIssueComments(
    request: ListIssueCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse {
    try await self.inner.listIssueComments(request: request, options: options)
  }

  /// Lists comments in an issue.
  ///
  /// @Snippet(path: "SecureSourceManager_ListIssueComments")
  public func listIssueComments(
    byItem: ListIssueCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<IssueComment, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listIssueComments(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Updates an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateIssueComment")
  public func updateIssueComment(
    request: UpdateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateIssueComment(request: request, options: options)
  }

  /// Updates an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_UpdateIssueComment")
  public func updateIssueComment(
    withPolling: UpdateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<IssueComment>.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 IssueComment(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.updateIssueComment(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<IssueComment>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Deletes an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteIssueComment")
  public func deleteIssueComment(
    request: DeleteIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteIssueComment(request: request, options: options)
  }

  /// Deletes an issue comment.
  ///
  /// @Snippet(path: "SecureSourceManager_DeleteIssueComment")
  public func deleteIssueComment(
    withPolling: DeleteIssueCommentRequest, 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.deleteIssueComment(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Void>.State in
      let op = try await self.getOperation(
        request: .init().with { $0.name = rawOp.name }, options: options)
      return try extractStatus(op)
    }
    return GoogleCloudGax._PollableOperationImpl(
      initialState: initialState,
      polling: options.pollingErrorPolicy ?? self.pollingErrorPolicy,
      backoff: options.pollingBackoffPolicy ?? self.pollingBackoffPolicy,
      poll: poll,
    )
  }

  /// Lists information about the supported locations for this service.
  ///
  /// This method lists locations based on the resource scope provided in
  /// the [ListLocationsRequest.name][google.cloud.location.ListLocationsRequest.name] field: *
  /// **Global locations**: If `name` is empty, the method lists the
  /// public locations available to all projects. * **Project-specific
  /// locations**: If `name` follows the format
  /// `projects/{project}`, the method lists locations visible to that
  /// specific project. This includes public, private, or other
  /// project-specific locations enabled for the project.
  ///
  /// For gRPC and client library implementations, the resource name is
  /// passed as the `name` field. For direct service calls, the resource
  /// name is
  /// incorporated into the request path based on the specific service
  /// implementation and version.
  ///
  /// [google.cloud.location.ListLocationsRequest.name]: https://www.google.com/search?q=Swift+google.cloud.location+GoogleCloudLocation.ListLocationsRequest/name
  ///
  /// @Snippet(path: "SecureSourceManager_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.
  ///
  /// This method lists locations based on the resource scope provided in
  /// the [ListLocationsRequest.name][google.cloud.location.ListLocationsRequest.name] field: *
  /// **Global locations**: If `name` is empty, the method lists the
  /// public locations available to all projects. * **Project-specific
  /// locations**: If `name` follows the format
  /// `projects/{project}`, the method lists locations visible to that
  /// specific project. This includes public, private, or other
  /// project-specific locations enabled for the project.
  ///
  /// For gRPC and client library implementations, the resource name is
  /// passed as the `name` field. For direct service calls, the resource
  /// name is
  /// incorporated into the request path based on the specific service
  /// implementation and version.
  ///
  /// [google.cloud.location.ListLocationsRequest.name]: https://www.google.com/search?q=Swift+google.cloud.location+GoogleCloudLocation.ListLocationsRequest/name
  ///
  /// @Snippet(path: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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: "SecureSourceManager_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 `SecureSourceManagerClient`.
  ///
  /// To mock `SecureSourceManagerClient` change your functions to receive
  /// `some SecureSourceManagerProtocol` or `any SecureSourceManagerProtocol`
  /// and pass a mock implementation in your tests.
  public protocol SecureSourceManagerProtocol {
    /// See `SecureSourceManagerClient.listInstances`.
    func listInstances(request: ListInstancesRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse

    /// See `SecureSourceManagerClient.listInstances`.
    func listInstances(
      byItem: ListInstancesRequest
    ) throws -> any AsyncSequence<Instance, Swift.Error>

    /// See `SecureSourceManagerClient.listInstances`.
    func listInstances(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Instance, Swift.Error>

    /// See `SecureSourceManagerClient.getInstance`.
    func getInstance(request: GetInstanceRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.Instance

    /// See `SecureSourceManagerClient.getInstance`.
    func getInstance(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.Instance

    /// See `SecureSourceManagerClient.createInstance`.
    func createInstance(request: CreateInstanceRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createInstance`.
    func createInstance(withPolling: CreateInstanceRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Instance>

    /// See `SecureSourceManagerClient.createInstance`.
    func createInstance(
      parent: Swift.String,
      instance: Instance?,
      instanceId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Instance>

    /// See `SecureSourceManagerClient.deleteInstance`.
    func deleteInstance(request: DeleteInstanceRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteInstance`.
    func deleteInstance(withPolling: DeleteInstanceRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `SecureSourceManagerClient.listRepositories`.
    func listRepositories(request: ListRepositoriesRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse

    /// See `SecureSourceManagerClient.listRepositories`.
    func listRepositories(
      byItem: ListRepositoriesRequest
    ) throws -> any AsyncSequence<Repository, Swift.Error>

    /// See `SecureSourceManagerClient.listRepositories`.
    func listRepositories(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Repository, Swift.Error>

    /// See `SecureSourceManagerClient.getRepository`.
    func getRepository(request: GetRepositoryRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.Repository

    /// See `SecureSourceManagerClient.getRepository`.
    func getRepository(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.Repository

    /// See `SecureSourceManagerClient.createRepository`.
    func createRepository(request: CreateRepositoryRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createRepository`.
    func createRepository(withPolling: CreateRepositoryRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Repository>

    /// See `SecureSourceManagerClient.createRepository`.
    func createRepository(
      parent: Swift.String,
      repository: Repository?,
      repositoryId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Repository>

    /// See `SecureSourceManagerClient.updateRepository`.
    func updateRepository(request: UpdateRepositoryRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateRepository`.
    func updateRepository(withPolling: UpdateRepositoryRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Repository>

    /// See `SecureSourceManagerClient.updateRepository`.
    func updateRepository(
      repository: Repository?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Repository>

    /// See `SecureSourceManagerClient.deleteRepository`.
    func deleteRepository(request: DeleteRepositoryRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteRepository`.
    func deleteRepository(withPolling: DeleteRepositoryRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `SecureSourceManagerClient.listHooks`.
    func listHooks(request: ListHooksRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListHooksResponse

    /// See `SecureSourceManagerClient.listHooks`.
    func listHooks(
      byItem: ListHooksRequest
    ) throws -> any AsyncSequence<Hook, Swift.Error>

    /// See `SecureSourceManagerClient.listHooks`.
    func listHooks(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Hook, Swift.Error>

    /// See `SecureSourceManagerClient.getHook`.
    func getHook(request: GetHookRequest) async throws -> GoogleCloudSecureSourceManagerV1.Hook

    /// See `SecureSourceManagerClient.getHook`.
    func getHook(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.Hook

    /// See `SecureSourceManagerClient.createHook`.
    func createHook(request: CreateHookRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createHook`.
    func createHook(withPolling: CreateHookRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Hook>

    /// See `SecureSourceManagerClient.createHook`.
    func createHook(
      parent: Swift.String,
      hook: Hook?,
      hookId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Hook>

    /// See `SecureSourceManagerClient.updateHook`.
    func updateHook(request: UpdateHookRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateHook`.
    func updateHook(withPolling: UpdateHookRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Hook>

    /// See `SecureSourceManagerClient.updateHook`.
    func updateHook(
      hook: Hook?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Hook>

    /// See `SecureSourceManagerClient.deleteHook`.
    func deleteHook(request: DeleteHookRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteHook`.
    func deleteHook(withPolling: DeleteHookRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

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

    /// See `SecureSourceManagerClient.getIamPolicyRepo`.
    func getIamPolicyRepo(
      resource: Swift.String,
    ) async throws -> GoogleIAMV1.Policy

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

    /// See `SecureSourceManagerClient.setIamPolicyRepo`.
    func setIamPolicyRepo(
      resource: Swift.String,
    ) async throws -> GoogleIAMV1.Policy

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

    /// See `SecureSourceManagerClient.testIamPermissionsRepo`.
    func testIamPermissionsRepo(
      resource: Swift.String,
    ) async throws -> GoogleIAMV1.TestIamPermissionsResponse

    /// See `SecureSourceManagerClient.createBranchRule`.
    func createBranchRule(request: CreateBranchRuleRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createBranchRule`.
    func createBranchRule(withPolling: CreateBranchRuleRequest) async throws -> any GoogleCloudGax
      .PollableOperation<BranchRule>

    /// See `SecureSourceManagerClient.createBranchRule`.
    func createBranchRule(
      parent: Swift.String,
      branchRule: BranchRule?,
      branchRuleId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule>

    /// See `SecureSourceManagerClient.listBranchRules`.
    func listBranchRules(request: ListBranchRulesRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse

    /// See `SecureSourceManagerClient.listBranchRules`.
    func listBranchRules(
      byItem: ListBranchRulesRequest
    ) throws -> any AsyncSequence<BranchRule, Swift.Error>

    /// See `SecureSourceManagerClient.listBranchRules`.
    func listBranchRules(
      parent: Swift.String,
    ) throws -> any AsyncSequence<BranchRule, Swift.Error>

    /// See `SecureSourceManagerClient.getBranchRule`.
    func getBranchRule(request: GetBranchRuleRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.BranchRule

    /// See `SecureSourceManagerClient.getBranchRule`.
    func getBranchRule(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.BranchRule

    /// See `SecureSourceManagerClient.updateBranchRule`.
    func updateBranchRule(request: UpdateBranchRuleRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateBranchRule`.
    func updateBranchRule(withPolling: UpdateBranchRuleRequest) async throws -> any GoogleCloudGax
      .PollableOperation<BranchRule>

    /// See `SecureSourceManagerClient.updateBranchRule`.
    func updateBranchRule(
      branchRule: BranchRule?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule>

    /// See `SecureSourceManagerClient.deleteBranchRule`.
    func deleteBranchRule(request: DeleteBranchRuleRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteBranchRule`.
    func deleteBranchRule(withPolling: DeleteBranchRuleRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `SecureSourceManagerClient.createPullRequest`.
    func createPullRequest(request: CreatePullRequestRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createPullRequest`.
    func createPullRequest(withPolling: CreatePullRequestRequest) async throws -> any GoogleCloudGax
      .PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.createPullRequest`.
    func createPullRequest(
      parent: Swift.String,
      pullRequest: PullRequest?,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.getPullRequest`.
    func getPullRequest(request: GetPullRequestRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.PullRequest

    /// See `SecureSourceManagerClient.getPullRequest`.
    func getPullRequest(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequest

    /// See `SecureSourceManagerClient.listPullRequests`.
    func listPullRequests(request: ListPullRequestsRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse

    /// See `SecureSourceManagerClient.listPullRequests`.
    func listPullRequests(
      byItem: ListPullRequestsRequest
    ) throws -> any AsyncSequence<PullRequest, Swift.Error>

    /// See `SecureSourceManagerClient.listPullRequests`.
    func listPullRequests(
      parent: Swift.String,
    ) throws -> any AsyncSequence<PullRequest, Swift.Error>

    /// See `SecureSourceManagerClient.updatePullRequest`.
    func updatePullRequest(request: UpdatePullRequestRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updatePullRequest`.
    func updatePullRequest(withPolling: UpdatePullRequestRequest) async throws -> any GoogleCloudGax
      .PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.updatePullRequest`.
    func updatePullRequest(
      pullRequest: PullRequest?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.mergePullRequest`.
    func mergePullRequest(request: MergePullRequestRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.mergePullRequest`.
    func mergePullRequest(withPolling: MergePullRequestRequest) async throws -> any GoogleCloudGax
      .PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.mergePullRequest`.
    func mergePullRequest(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.openPullRequest`.
    func openPullRequest(request: OpenPullRequestRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.openPullRequest`.
    func openPullRequest(withPolling: OpenPullRequestRequest) async throws -> any GoogleCloudGax
      .PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.openPullRequest`.
    func openPullRequest(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.closePullRequest`.
    func closePullRequest(request: ClosePullRequestRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.closePullRequest`.
    func closePullRequest(withPolling: ClosePullRequestRequest) async throws -> any GoogleCloudGax
      .PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.closePullRequest`.
    func closePullRequest(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.listPullRequestFileDiffs`.
    func listPullRequestFileDiffs(request: ListPullRequestFileDiffsRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse

    /// See `SecureSourceManagerClient.listPullRequestFileDiffs`.
    func listPullRequestFileDiffs(
      byItem: ListPullRequestFileDiffsRequest
    ) throws -> any AsyncSequence<FileDiff, Swift.Error>

    /// See `SecureSourceManagerClient.listPullRequestFileDiffs`.
    func listPullRequestFileDiffs(
      name: Swift.String,
    ) throws -> any AsyncSequence<FileDiff, Swift.Error>

    /// See `SecureSourceManagerClient.fetchTree`.
    func fetchTree(request: FetchTreeRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse

    /// See `SecureSourceManagerClient.fetchTree`.
    func fetchTree(
      byItem: FetchTreeRequest
    ) throws -> any AsyncSequence<TreeEntry, Swift.Error>

    /// See `SecureSourceManagerClient.fetchBlob`.
    func fetchBlob(request: FetchBlobRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.FetchBlobResponse

    /// See `SecureSourceManagerClient.createIssue`.
    func createIssue(request: CreateIssueRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createIssue`.
    func createIssue(withPolling: CreateIssueRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Issue>

    /// See `SecureSourceManagerClient.createIssue`.
    func createIssue(
      parent: Swift.String,
      issue: Issue?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.getIssue`.
    func getIssue(request: GetIssueRequest) async throws -> GoogleCloudSecureSourceManagerV1.Issue

    /// See `SecureSourceManagerClient.getIssue`.
    func getIssue(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.Issue

    /// See `SecureSourceManagerClient.listIssues`.
    func listIssues(request: ListIssuesRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse

    /// See `SecureSourceManagerClient.listIssues`.
    func listIssues(
      byItem: ListIssuesRequest
    ) throws -> any AsyncSequence<Issue, Swift.Error>

    /// See `SecureSourceManagerClient.listIssues`.
    func listIssues(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Issue, Swift.Error>

    /// See `SecureSourceManagerClient.updateIssue`.
    func updateIssue(request: UpdateIssueRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateIssue`.
    func updateIssue(withPolling: UpdateIssueRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Issue>

    /// See `SecureSourceManagerClient.updateIssue`.
    func updateIssue(
      issue: Issue?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.deleteIssue`.
    func deleteIssue(request: DeleteIssueRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteIssue`.
    func deleteIssue(withPolling: DeleteIssueRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `SecureSourceManagerClient.openIssue`.
    func openIssue(request: OpenIssueRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.openIssue`.
    func openIssue(withPolling: OpenIssueRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Issue>

    /// See `SecureSourceManagerClient.openIssue`.
    func openIssue(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.closeIssue`.
    func closeIssue(request: CloseIssueRequest) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.closeIssue`.
    func closeIssue(withPolling: CloseIssueRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Issue>

    /// See `SecureSourceManagerClient.closeIssue`.
    func closeIssue(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.getPullRequestComment`.
    func getPullRequestComment(request: GetPullRequestCommentRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.PullRequestComment

    /// See `SecureSourceManagerClient.getPullRequestComment`.
    func getPullRequestComment(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequestComment

    /// See `SecureSourceManagerClient.listPullRequestComments`.
    func listPullRequestComments(request: ListPullRequestCommentsRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse

    /// See `SecureSourceManagerClient.listPullRequestComments`.
    func listPullRequestComments(
      byItem: ListPullRequestCommentsRequest
    ) throws -> any AsyncSequence<PullRequestComment, Swift.Error>

    /// See `SecureSourceManagerClient.listPullRequestComments`.
    func listPullRequestComments(
      parent: Swift.String,
    ) throws -> any AsyncSequence<PullRequestComment, Swift.Error>

    /// See `SecureSourceManagerClient.createPullRequestComment`.
    func createPullRequestComment(request: CreatePullRequestCommentRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createPullRequestComment`.
    func createPullRequestComment(withPolling: CreatePullRequestCommentRequest) async throws
      -> any GoogleCloudGax.PollableOperation<PullRequestComment>

    /// See `SecureSourceManagerClient.createPullRequestComment`.
    func createPullRequestComment(
      parent: Swift.String,
      pullRequestComment: PullRequestComment?,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment>

    /// See `SecureSourceManagerClient.updatePullRequestComment`.
    func updatePullRequestComment(request: UpdatePullRequestCommentRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updatePullRequestComment`.
    func updatePullRequestComment(withPolling: UpdatePullRequestCommentRequest) async throws
      -> any GoogleCloudGax.PollableOperation<PullRequestComment>

    /// See `SecureSourceManagerClient.updatePullRequestComment`.
    func updatePullRequestComment(
      pullRequestComment: PullRequestComment?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment>

    /// See `SecureSourceManagerClient.deletePullRequestComment`.
    func deletePullRequestComment(request: DeletePullRequestCommentRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deletePullRequestComment`.
    func deletePullRequestComment(withPolling: DeletePullRequestCommentRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `SecureSourceManagerClient.batchCreatePullRequestComments`.
    func batchCreatePullRequestComments(request: BatchCreatePullRequestCommentsRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.batchCreatePullRequestComments`.
    func batchCreatePullRequestComments(withPolling: BatchCreatePullRequestCommentsRequest)
      async throws -> any GoogleCloudGax.PollableOperation<BatchCreatePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.batchCreatePullRequestComments`.
    func batchCreatePullRequestComments(
      parent: Swift.String,
      requests: [CreatePullRequestCommentRequest],
    ) async throws -> any GoogleCloudGax.PollableOperation<BatchCreatePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.resolvePullRequestComments`.
    func resolvePullRequestComments(request: ResolvePullRequestCommentsRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.resolvePullRequestComments`.
    func resolvePullRequestComments(withPolling: ResolvePullRequestCommentsRequest) async throws
      -> any GoogleCloudGax.PollableOperation<ResolvePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.resolvePullRequestComments`.
    func resolvePullRequestComments(
      parent: Swift.String,
      names: [Swift.String],
    ) async throws -> any GoogleCloudGax.PollableOperation<ResolvePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.unresolvePullRequestComments`.
    func unresolvePullRequestComments(request: UnresolvePullRequestCommentsRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.unresolvePullRequestComments`.
    func unresolvePullRequestComments(withPolling: UnresolvePullRequestCommentsRequest) async throws
      -> any GoogleCloudGax.PollableOperation<UnresolvePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.unresolvePullRequestComments`.
    func unresolvePullRequestComments(
      parent: Swift.String,
      names: [Swift.String],
    ) async throws -> any GoogleCloudGax.PollableOperation<UnresolvePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.createIssueComment`.
    func createIssueComment(request: CreateIssueCommentRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createIssueComment`.
    func createIssueComment(withPolling: CreateIssueCommentRequest) async throws
      -> any GoogleCloudGax.PollableOperation<IssueComment>

    /// See `SecureSourceManagerClient.createIssueComment`.
    func createIssueComment(
      parent: Swift.String,
      issueComment: IssueComment?,
    ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment>

    /// See `SecureSourceManagerClient.getIssueComment`.
    func getIssueComment(request: GetIssueCommentRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.IssueComment

    /// See `SecureSourceManagerClient.getIssueComment`.
    func getIssueComment(
      name: Swift.String,
    ) async throws -> GoogleCloudSecureSourceManagerV1.IssueComment

    /// See `SecureSourceManagerClient.listIssueComments`.
    func listIssueComments(request: ListIssueCommentsRequest) async throws
      -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse

    /// See `SecureSourceManagerClient.listIssueComments`.
    func listIssueComments(
      byItem: ListIssueCommentsRequest
    ) throws -> any AsyncSequence<IssueComment, Swift.Error>

    /// See `SecureSourceManagerClient.listIssueComments`.
    func listIssueComments(
      parent: Swift.String,
    ) throws -> any AsyncSequence<IssueComment, Swift.Error>

    /// See `SecureSourceManagerClient.updateIssueComment`.
    func updateIssueComment(request: UpdateIssueCommentRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateIssueComment`.
    func updateIssueComment(withPolling: UpdateIssueCommentRequest) async throws
      -> any GoogleCloudGax.PollableOperation<IssueComment>

    /// See `SecureSourceManagerClient.updateIssueComment`.
    func updateIssueComment(
      issueComment: IssueComment?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment>

    /// See `SecureSourceManagerClient.deleteIssueComment`.
    func deleteIssueComment(request: DeleteIssueCommentRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteIssueComment`.
    func deleteIssueComment(withPolling: DeleteIssueCommentRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// See `SecureSourceManagerClient.listInstances`.
    func listInstances(
      request: ListInstancesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse

    /// See `SecureSourceManagerClient.listInstances`.
    func listInstances(
      byItem: ListInstancesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Instance, Swift.Error>

    /// See `SecureSourceManagerClient.getInstance`.
    func getInstance(
      request: GetInstanceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.Instance

    /// See `SecureSourceManagerClient.createInstance`.
    func createInstance(
      request: CreateInstanceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createInstance`.
    func createInstance(
      withPolling: CreateInstanceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Instance>

    /// See `SecureSourceManagerClient.deleteInstance`.
    func deleteInstance(
      request: DeleteInstanceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteInstance`.
    func deleteInstance(
      withPolling: DeleteInstanceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `SecureSourceManagerClient.listRepositories`.
    func listRepositories(
      request: ListRepositoriesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse

    /// See `SecureSourceManagerClient.listRepositories`.
    func listRepositories(
      byItem: ListRepositoriesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Repository, Swift.Error>

    /// See `SecureSourceManagerClient.getRepository`.
    func getRepository(
      request: GetRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.Repository

    /// See `SecureSourceManagerClient.createRepository`.
    func createRepository(
      request: CreateRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createRepository`.
    func createRepository(
      withPolling: CreateRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Repository>

    /// See `SecureSourceManagerClient.updateRepository`.
    func updateRepository(
      request: UpdateRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateRepository`.
    func updateRepository(
      withPolling: UpdateRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Repository>

    /// See `SecureSourceManagerClient.deleteRepository`.
    func deleteRepository(
      request: DeleteRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteRepository`.
    func deleteRepository(
      withPolling: DeleteRepositoryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `SecureSourceManagerClient.listHooks`.
    func listHooks(
      request: ListHooksRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListHooksResponse

    /// See `SecureSourceManagerClient.listHooks`.
    func listHooks(
      byItem: ListHooksRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Hook, Swift.Error>

    /// See `SecureSourceManagerClient.getHook`.
    func getHook(
      request: GetHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.Hook

    /// See `SecureSourceManagerClient.createHook`.
    func createHook(
      request: CreateHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createHook`.
    func createHook(
      withPolling: CreateHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Hook>

    /// See `SecureSourceManagerClient.updateHook`.
    func updateHook(
      request: UpdateHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateHook`.
    func updateHook(
      withPolling: UpdateHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Hook>

    /// See `SecureSourceManagerClient.deleteHook`.
    func deleteHook(
      request: DeleteHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteHook`.
    func deleteHook(
      withPolling: DeleteHookRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

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

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

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

    /// See `SecureSourceManagerClient.createBranchRule`.
    func createBranchRule(
      request: CreateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createBranchRule`.
    func createBranchRule(
      withPolling: CreateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule>

    /// See `SecureSourceManagerClient.listBranchRules`.
    func listBranchRules(
      request: ListBranchRulesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse

    /// See `SecureSourceManagerClient.listBranchRules`.
    func listBranchRules(
      byItem: ListBranchRulesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<BranchRule, Swift.Error>

    /// See `SecureSourceManagerClient.getBranchRule`.
    func getBranchRule(
      request: GetBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.BranchRule

    /// See `SecureSourceManagerClient.updateBranchRule`.
    func updateBranchRule(
      request: UpdateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateBranchRule`.
    func updateBranchRule(
      withPolling: UpdateBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule>

    /// See `SecureSourceManagerClient.deleteBranchRule`.
    func deleteBranchRule(
      request: DeleteBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteBranchRule`.
    func deleteBranchRule(
      withPolling: DeleteBranchRuleRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `SecureSourceManagerClient.createPullRequest`.
    func createPullRequest(
      request: CreatePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createPullRequest`.
    func createPullRequest(
      withPolling: CreatePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.getPullRequest`.
    func getPullRequest(
      request: GetPullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequest

    /// See `SecureSourceManagerClient.listPullRequests`.
    func listPullRequests(
      request: ListPullRequestsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse

    /// See `SecureSourceManagerClient.listPullRequests`.
    func listPullRequests(
      byItem: ListPullRequestsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<PullRequest, Swift.Error>

    /// See `SecureSourceManagerClient.updatePullRequest`.
    func updatePullRequest(
      request: UpdatePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updatePullRequest`.
    func updatePullRequest(
      withPolling: UpdatePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.mergePullRequest`.
    func mergePullRequest(
      request: MergePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.mergePullRequest`.
    func mergePullRequest(
      withPolling: MergePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.openPullRequest`.
    func openPullRequest(
      request: OpenPullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.openPullRequest`.
    func openPullRequest(
      withPolling: OpenPullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.closePullRequest`.
    func closePullRequest(
      request: ClosePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.closePullRequest`.
    func closePullRequest(
      withPolling: ClosePullRequestRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest>

    /// See `SecureSourceManagerClient.listPullRequestFileDiffs`.
    func listPullRequestFileDiffs(
      request: ListPullRequestFileDiffsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse

    /// See `SecureSourceManagerClient.listPullRequestFileDiffs`.
    func listPullRequestFileDiffs(
      byItem: ListPullRequestFileDiffsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<FileDiff, Swift.Error>

    /// See `SecureSourceManagerClient.fetchTree`.
    func fetchTree(
      request: FetchTreeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse

    /// See `SecureSourceManagerClient.fetchTree`.
    func fetchTree(
      byItem: FetchTreeRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<TreeEntry, Swift.Error>

    /// See `SecureSourceManagerClient.fetchBlob`.
    func fetchBlob(
      request: FetchBlobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.FetchBlobResponse

    /// See `SecureSourceManagerClient.createIssue`.
    func createIssue(
      request: CreateIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createIssue`.
    func createIssue(
      withPolling: CreateIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.getIssue`.
    func getIssue(
      request: GetIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.Issue

    /// See `SecureSourceManagerClient.listIssues`.
    func listIssues(
      request: ListIssuesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse

    /// See `SecureSourceManagerClient.listIssues`.
    func listIssues(
      byItem: ListIssuesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Issue, Swift.Error>

    /// See `SecureSourceManagerClient.updateIssue`.
    func updateIssue(
      request: UpdateIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateIssue`.
    func updateIssue(
      withPolling: UpdateIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.deleteIssue`.
    func deleteIssue(
      request: DeleteIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteIssue`.
    func deleteIssue(
      withPolling: DeleteIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `SecureSourceManagerClient.openIssue`.
    func openIssue(
      request: OpenIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.openIssue`.
    func openIssue(
      withPolling: OpenIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.closeIssue`.
    func closeIssue(
      request: CloseIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.closeIssue`.
    func closeIssue(
      withPolling: CloseIssueRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Issue>

    /// See `SecureSourceManagerClient.getPullRequestComment`.
    func getPullRequestComment(
      request: GetPullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequestComment

    /// See `SecureSourceManagerClient.listPullRequestComments`.
    func listPullRequestComments(
      request: ListPullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse

    /// See `SecureSourceManagerClient.listPullRequestComments`.
    func listPullRequestComments(
      byItem: ListPullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<PullRequestComment, Swift.Error>

    /// See `SecureSourceManagerClient.createPullRequestComment`.
    func createPullRequestComment(
      request: CreatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createPullRequestComment`.
    func createPullRequestComment(
      withPolling: CreatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment>

    /// See `SecureSourceManagerClient.updatePullRequestComment`.
    func updatePullRequestComment(
      request: UpdatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updatePullRequestComment`.
    func updatePullRequestComment(
      withPolling: UpdatePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment>

    /// See `SecureSourceManagerClient.deletePullRequestComment`.
    func deletePullRequestComment(
      request: DeletePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deletePullRequestComment`.
    func deletePullRequestComment(
      withPolling: DeletePullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `SecureSourceManagerClient.batchCreatePullRequestComments`.
    func batchCreatePullRequestComments(
      request: BatchCreatePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.batchCreatePullRequestComments`.
    func batchCreatePullRequestComments(
      withPolling: BatchCreatePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<BatchCreatePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.resolvePullRequestComments`.
    func resolvePullRequestComments(
      request: ResolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.resolvePullRequestComments`.
    func resolvePullRequestComments(
      withPolling: ResolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<ResolvePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.unresolvePullRequestComments`.
    func unresolvePullRequestComments(
      request: UnresolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.unresolvePullRequestComments`.
    func unresolvePullRequestComments(
      withPolling: UnresolvePullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<UnresolvePullRequestCommentsResponse>

    /// See `SecureSourceManagerClient.createIssueComment`.
    func createIssueComment(
      request: CreateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.createIssueComment`.
    func createIssueComment(
      withPolling: CreateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment>

    /// See `SecureSourceManagerClient.getIssueComment`.
    func getIssueComment(
      request: GetIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.IssueComment

    /// See `SecureSourceManagerClient.listIssueComments`.
    func listIssueComments(
      request: ListIssueCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse

    /// See `SecureSourceManagerClient.listIssueComments`.
    func listIssueComments(
      byItem: ListIssueCommentsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<IssueComment, Swift.Error>

    /// See `SecureSourceManagerClient.updateIssueComment`.
    func updateIssueComment(
      request: UpdateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.updateIssueComment`.
    func updateIssueComment(
      withPolling: UpdateIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment>

    /// See `SecureSourceManagerClient.deleteIssueComment`.
    func deleteIssueComment(
      request: DeleteIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `SecureSourceManagerClient.deleteIssueComment`.
    func deleteIssueComment(
      withPolling: DeleteIssueCommentRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

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

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

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

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

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

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

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

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

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

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

// Default implementations
extension Clients.SecureSourceManagerProtocol {
  public func listInstances(request: ListInstancesRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse
  {
    try await self.listInstances(request: request, options: .init())
  }

  public func listInstances(
    request: ListInstancesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listInstances(
    byItem: ListInstancesRequest
  ) throws -> any AsyncSequence<Instance, Swift.Error> {
    try self.listInstances(byItem: byItem, options: .init())
  }

  public func listInstances(
    byItem: ListInstancesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Instance, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListInstancesResponse
      in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getInstance(request: GetInstanceRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.Instance
  {
    try await self.getInstance(request: request, options: .init())
  }

  public func getInstance(
    request: GetInstanceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Instance {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getInstance(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.Instance {
    let request = GetInstanceRequest().with {
      $0.name = name
    }
    return try await self.getInstance(request: request)
  }

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

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

  public func createInstance(withPolling: CreateInstanceRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Instance>
  {
    try await self.createInstance(withPolling: withPolling, options: .init())
  }

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

  public func createInstance(
    parent: Swift.String,
    instance: Instance?,
    instanceId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Instance> {
    let request = CreateInstanceRequest().with {
      $0.parent = parent
      $0.instance = instance
      $0.instanceId = instanceId
    }
    return try await self.createInstance(withPolling: request)
  }

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

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

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

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

  public func listRepositories(request: ListRepositoriesRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse
  {
    try await self.listRepositories(request: request, options: .init())
  }

  public func listRepositories(
    request: ListRepositoriesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listRepositories(
    byItem: ListRepositoriesRequest
  ) throws -> any AsyncSequence<Repository, Swift.Error> {
    try self.listRepositories(byItem: byItem, options: .init())
  }

  public func listRepositories(
    byItem: ListRepositoriesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Repository, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListRepositoriesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getRepository(request: GetRepositoryRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.Repository
  {
    try await self.getRepository(request: request, options: .init())
  }

  public func getRepository(
    request: GetRepositoryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Repository {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getRepository(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.Repository {
    let request = GetRepositoryRequest().with {
      $0.name = name
    }
    return try await self.getRepository(request: request)
  }

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

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

  public func createRepository(withPolling: CreateRepositoryRequest) async throws
    -> any GoogleCloudGax.PollableOperation<Repository>
  {
    try await self.createRepository(withPolling: withPolling, options: .init())
  }

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

  public func createRepository(
    parent: Swift.String,
    repository: Repository?,
    repositoryId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Repository> {
    let request = CreateRepositoryRequest().with {
      $0.parent = parent
      $0.repository = repository
      $0.repositoryId = repositoryId
    }
    return try await self.createRepository(withPolling: request)
  }

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

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

  public func updateRepository(withPolling: UpdateRepositoryRequest) async throws
    -> any GoogleCloudGax.PollableOperation<Repository>
  {
    try await self.updateRepository(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

  public func listHooks(request: ListHooksRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListHooksResponse
  {
    try await self.listHooks(request: request, options: .init())
  }

  public func listHooks(
    request: ListHooksRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListHooksResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listHooks(
    byItem: ListHooksRequest
  ) throws -> any AsyncSequence<Hook, Swift.Error> {
    try self.listHooks(byItem: byItem, options: .init())
  }

  public func listHooks(
    byItem: ListHooksRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Hook, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListHooksResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getHook(request: GetHookRequest) async throws -> GoogleCloudSecureSourceManagerV1.Hook
  {
    try await self.getHook(request: request, options: .init())
  }

  public func getHook(
    request: GetHookRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Hook {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getHook(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.Hook {
    let request = GetHookRequest().with {
      $0.name = name
    }
    return try await self.getHook(request: request)
  }

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

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

  public func createHook(withPolling: CreateHookRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Hook>
  {
    try await self.createHook(withPolling: withPolling, options: .init())
  }

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

  public func createHook(
    parent: Swift.String,
    hook: Hook?,
    hookId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Hook> {
    let request = CreateHookRequest().with {
      $0.parent = parent
      $0.hook = hook
      $0.hookId = hookId
    }
    return try await self.createHook(withPolling: request)
  }

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

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

  public func updateHook(withPolling: UpdateHookRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Hook>
  {
    try await self.updateHook(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

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

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

  public func getIamPolicyRepo(
    resource: Swift.String,
  ) async throws -> GoogleIAMV1.Policy {
    let request = GoogleIAMV1.GetIamPolicyRequest().with {
      $0.resource = resource
    }
    return try await self.getIamPolicyRepo(request: request)
  }

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

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

  public func setIamPolicyRepo(
    resource: Swift.String,
  ) async throws -> GoogleIAMV1.Policy {
    let request = GoogleIAMV1.SetIamPolicyRequest().with {
      $0.resource = resource
    }
    return try await self.setIamPolicyRepo(request: request)
  }

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

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

  public func testIamPermissionsRepo(
    resource: Swift.String,
  ) async throws -> GoogleIAMV1.TestIamPermissionsResponse {
    let request = GoogleIAMV1.TestIamPermissionsRequest().with {
      $0.resource = resource
    }
    return try await self.testIamPermissionsRepo(request: request)
  }

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

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

  public func createBranchRule(withPolling: CreateBranchRuleRequest) async throws
    -> any GoogleCloudGax.PollableOperation<BranchRule>
  {
    try await self.createBranchRule(withPolling: withPolling, options: .init())
  }

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

  public func createBranchRule(
    parent: Swift.String,
    branchRule: BranchRule?,
    branchRuleId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<BranchRule> {
    let request = CreateBranchRuleRequest().with {
      $0.parent = parent
      $0.branchRule = branchRule
      $0.branchRuleId = branchRuleId
    }
    return try await self.createBranchRule(withPolling: request)
  }

  public func listBranchRules(request: ListBranchRulesRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse
  {
    try await self.listBranchRules(request: request, options: .init())
  }

  public func listBranchRules(
    request: ListBranchRulesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listBranchRules(
    byItem: ListBranchRulesRequest
  ) throws -> any AsyncSequence<BranchRule, Swift.Error> {
    try self.listBranchRules(byItem: byItem, options: .init())
  }

  public func listBranchRules(
    byItem: ListBranchRulesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<BranchRule, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListBranchRulesResponse
      in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getBranchRule(request: GetBranchRuleRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.BranchRule
  {
    try await self.getBranchRule(request: request, options: .init())
  }

  public func getBranchRule(
    request: GetBranchRuleRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.BranchRule {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getBranchRule(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.BranchRule {
    let request = GetBranchRuleRequest().with {
      $0.name = name
    }
    return try await self.getBranchRule(request: request)
  }

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

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

  public func updateBranchRule(withPolling: UpdateBranchRuleRequest) async throws
    -> any GoogleCloudGax.PollableOperation<BranchRule>
  {
    try await self.updateBranchRule(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

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

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

  public func createPullRequest(withPolling: CreatePullRequestRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequest>
  {
    try await self.createPullRequest(withPolling: withPolling, options: .init())
  }

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

  public func createPullRequest(
    parent: Swift.String,
    pullRequest: PullRequest?,
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequest> {
    let request = CreatePullRequestRequest().with {
      $0.parent = parent
      $0.pullRequest = pullRequest
    }
    return try await self.createPullRequest(withPolling: request)
  }

  public func getPullRequest(request: GetPullRequestRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.PullRequest
  {
    try await self.getPullRequest(request: request, options: .init())
  }

  public func getPullRequest(
    request: GetPullRequestRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequest {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getPullRequest(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequest {
    let request = GetPullRequestRequest().with {
      $0.name = name
    }
    return try await self.getPullRequest(request: request)
  }

  public func listPullRequests(request: ListPullRequestsRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse
  {
    try await self.listPullRequests(request: request, options: .init())
  }

  public func listPullRequests(
    request: ListPullRequestsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listPullRequests(
    byItem: ListPullRequestsRequest
  ) throws -> any AsyncSequence<PullRequest, Swift.Error> {
    try self.listPullRequests(byItem: byItem, options: .init())
  }

  public func listPullRequests(
    byItem: ListPullRequestsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<PullRequest, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListPullRequestsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

  public func updatePullRequest(withPolling: UpdatePullRequestRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequest>
  {
    try await self.updatePullRequest(withPolling: withPolling, options: .init())
  }

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

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

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

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

  public func mergePullRequest(withPolling: MergePullRequestRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequest>
  {
    try await self.mergePullRequest(withPolling: withPolling, options: .init())
  }

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

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

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

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

  public func openPullRequest(withPolling: OpenPullRequestRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequest>
  {
    try await self.openPullRequest(withPolling: withPolling, options: .init())
  }

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

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

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

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

  public func closePullRequest(withPolling: ClosePullRequestRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequest>
  {
    try await self.closePullRequest(withPolling: withPolling, options: .init())
  }

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

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

  public func listPullRequestFileDiffs(request: ListPullRequestFileDiffsRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse
  {
    try await self.listPullRequestFileDiffs(request: request, options: .init())
  }

  public func listPullRequestFileDiffs(
    request: ListPullRequestFileDiffsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listPullRequestFileDiffs(
    byItem: ListPullRequestFileDiffsRequest
  ) throws -> any AsyncSequence<FileDiff, Swift.Error> {
    try self.listPullRequestFileDiffs(byItem: byItem, options: .init())
  }

  public func listPullRequestFileDiffs(
    byItem: ListPullRequestFileDiffsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<FileDiff, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListPullRequestFileDiffsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func listPullRequestFileDiffs(
    name: Swift.String,
  ) throws -> any AsyncSequence<FileDiff, Swift.Error> {
    let request = ListPullRequestFileDiffsRequest().with {
      $0.name = name
    }
    return try self.listPullRequestFileDiffs(byItem: request)
  }

  public func fetchTree(request: FetchTreeRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse
  {
    try await self.fetchTree(request: request, options: .init())
  }

  public func fetchTree(
    request: FetchTreeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func fetchTree(
    byItem: FetchTreeRequest
  ) throws -> any AsyncSequence<TreeEntry, Swift.Error> {
    try self.fetchTree(byItem: byItem, options: .init())
  }

  public func fetchTree(
    byItem: FetchTreeRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<TreeEntry, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.FetchTreeResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func fetchBlob(request: FetchBlobRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.FetchBlobResponse
  {
    try await self.fetchBlob(request: request, options: .init())
  }

  public func fetchBlob(
    request: FetchBlobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.FetchBlobResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

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

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

  public func createIssue(withPolling: CreateIssueRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Issue>
  {
    try await self.createIssue(withPolling: withPolling, options: .init())
  }

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

  public func createIssue(
    parent: Swift.String,
    issue: Issue?,
  ) async throws -> any GoogleCloudGax.PollableOperation<Issue> {
    let request = CreateIssueRequest().with {
      $0.parent = parent
      $0.issue = issue
    }
    return try await self.createIssue(withPolling: request)
  }

  public func getIssue(request: GetIssueRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.Issue
  {
    try await self.getIssue(request: request, options: .init())
  }

  public func getIssue(
    request: GetIssueRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.Issue {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getIssue(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.Issue {
    let request = GetIssueRequest().with {
      $0.name = name
    }
    return try await self.getIssue(request: request)
  }

  public func listIssues(request: ListIssuesRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse
  {
    try await self.listIssues(request: request, options: .init())
  }

  public func listIssues(
    request: ListIssuesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listIssues(
    byItem: ListIssuesRequest
  ) throws -> any AsyncSequence<Issue, Swift.Error> {
    try self.listIssues(byItem: byItem, options: .init())
  }

  public func listIssues(
    byItem: ListIssuesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Issue, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudSecureSourceManagerV1.ListIssuesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

  public func updateIssue(withPolling: UpdateIssueRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Issue>
  {
    try await self.updateIssue(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

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

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

  public func openIssue(withPolling: OpenIssueRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Issue>
  {
    try await self.openIssue(withPolling: withPolling, options: .init())
  }

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

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

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

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

  public func closeIssue(withPolling: CloseIssueRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Issue>
  {
    try await self.closeIssue(withPolling: withPolling, options: .init())
  }

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

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

  public func getPullRequestComment(request: GetPullRequestCommentRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.PullRequestComment
  {
    try await self.getPullRequestComment(request: request, options: .init())
  }

  public func getPullRequestComment(
    request: GetPullRequestCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequestComment {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getPullRequestComment(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.PullRequestComment {
    let request = GetPullRequestCommentRequest().with {
      $0.name = name
    }
    return try await self.getPullRequestComment(request: request)
  }

  public func listPullRequestComments(request: ListPullRequestCommentsRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse
  {
    try await self.listPullRequestComments(request: request, options: .init())
  }

  public func listPullRequestComments(
    request: ListPullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listPullRequestComments(
    byItem: ListPullRequestCommentsRequest
  ) throws -> any AsyncSequence<PullRequestComment, Swift.Error> {
    try self.listPullRequestComments(byItem: byItem, options: .init())
  }

  public func listPullRequestComments(
    byItem: ListPullRequestCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<PullRequestComment, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListPullRequestCommentsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

  public func createPullRequestComment(withPolling: CreatePullRequestCommentRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequestComment>
  {
    try await self.createPullRequestComment(withPolling: withPolling, options: .init())
  }

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

  public func createPullRequestComment(
    parent: Swift.String,
    pullRequestComment: PullRequestComment?,
  ) async throws -> any GoogleCloudGax.PollableOperation<PullRequestComment> {
    let request = CreatePullRequestCommentRequest().with {
      $0.parent = parent
      $0.pullRequestComment = pullRequestComment
    }
    return try await self.createPullRequestComment(withPolling: request)
  }

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

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

  public func updatePullRequestComment(withPolling: UpdatePullRequestCommentRequest) async throws
    -> any GoogleCloudGax.PollableOperation<PullRequestComment>
  {
    try await self.updatePullRequestComment(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

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

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

  public func batchCreatePullRequestComments(withPolling: BatchCreatePullRequestCommentsRequest)
    async throws -> any GoogleCloudGax.PollableOperation<BatchCreatePullRequestCommentsResponse>
  {
    try await self.batchCreatePullRequestComments(withPolling: withPolling, options: .init())
  }

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

  public func batchCreatePullRequestComments(
    parent: Swift.String,
    requests: [CreatePullRequestCommentRequest],
  ) async throws -> any GoogleCloudGax.PollableOperation<BatchCreatePullRequestCommentsResponse> {
    let request = BatchCreatePullRequestCommentsRequest().with {
      $0.parent = parent
      $0.requests = requests
    }
    return try await self.batchCreatePullRequestComments(withPolling: request)
  }

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

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

  public func resolvePullRequestComments(withPolling: ResolvePullRequestCommentsRequest)
    async throws -> any GoogleCloudGax.PollableOperation<ResolvePullRequestCommentsResponse>
  {
    try await self.resolvePullRequestComments(withPolling: withPolling, options: .init())
  }

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

  public func resolvePullRequestComments(
    parent: Swift.String,
    names: [Swift.String],
  ) async throws -> any GoogleCloudGax.PollableOperation<ResolvePullRequestCommentsResponse> {
    let request = ResolvePullRequestCommentsRequest().with {
      $0.parent = parent
      $0.names = names
    }
    return try await self.resolvePullRequestComments(withPolling: request)
  }

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

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

  public func unresolvePullRequestComments(withPolling: UnresolvePullRequestCommentsRequest)
    async throws -> any GoogleCloudGax.PollableOperation<UnresolvePullRequestCommentsResponse>
  {
    try await self.unresolvePullRequestComments(withPolling: withPolling, options: .init())
  }

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

  public func unresolvePullRequestComments(
    parent: Swift.String,
    names: [Swift.String],
  ) async throws -> any GoogleCloudGax.PollableOperation<UnresolvePullRequestCommentsResponse> {
    let request = UnresolvePullRequestCommentsRequest().with {
      $0.parent = parent
      $0.names = names
    }
    return try await self.unresolvePullRequestComments(withPolling: request)
  }

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

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

  public func createIssueComment(withPolling: CreateIssueCommentRequest) async throws
    -> any GoogleCloudGax.PollableOperation<IssueComment>
  {
    try await self.createIssueComment(withPolling: withPolling, options: .init())
  }

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

  public func createIssueComment(
    parent: Swift.String,
    issueComment: IssueComment?,
  ) async throws -> any GoogleCloudGax.PollableOperation<IssueComment> {
    let request = CreateIssueCommentRequest().with {
      $0.parent = parent
      $0.issueComment = issueComment
    }
    return try await self.createIssueComment(withPolling: request)
  }

  public func getIssueComment(request: GetIssueCommentRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.IssueComment
  {
    try await self.getIssueComment(request: request, options: .init())
  }

  public func getIssueComment(
    request: GetIssueCommentRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.IssueComment {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getIssueComment(
    name: Swift.String,
  ) async throws -> GoogleCloudSecureSourceManagerV1.IssueComment {
    let request = GetIssueCommentRequest().with {
      $0.name = name
    }
    return try await self.getIssueComment(request: request)
  }

  public func listIssueComments(request: ListIssueCommentsRequest) async throws
    -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse
  {
    try await self.listIssueComments(request: request, options: .init())
  }

  public func listIssueComments(
    request: ListIssueCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listIssueComments(
    byItem: ListIssueCommentsRequest
  ) throws -> any AsyncSequence<IssueComment, Swift.Error> {
    try self.listIssueComments(byItem: byItem, options: .init())
  }

  public func listIssueComments(
    byItem: ListIssueCommentsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<IssueComment, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws
        -> GoogleCloudSecureSourceManagerV1.ListIssueCommentsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

  public func updateIssueComment(withPolling: UpdateIssueCommentRequest) async throws
    -> any GoogleCloudGax.PollableOperation<IssueComment>
  {
    try await self.updateIssueComment(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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