// 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 GoogleLongRunning
import GoogleRpc
import GoogleCloudGax

/// Manages TPU nodes and other resources
///
/// TPU API v2
///
/// @Snippet(path: "TpuQuickstart")
public class TpuClient: Clients.TpuProtocol {
  let inner: any Clients.TpuStub
  let pollingErrorPolicy: GoogleCloudGax.PollingErrorPolicy
  let pollingBackoffPolicy: GoogleCloudGax.BackoffPolicy

  /// Creates a new `TpuClient` instance.
  public init(_ options: GoogleCloudGax.ClientOptions = .init()) throws {
    var inner: any Clients.TpuStub = try Clients.TpuTransport(options)
    inner = Clients.TpuRetry(inner, options: options)
    if let logger = options.logger {
      inner = Clients.TpuLogging(inner, logger: logger)
    }
    self.inner = inner
    self.pollingErrorPolicy = options.pollingErrorPolicy
    self.pollingBackoffPolicy = options.pollingBackoffPolicy
  }

  /// Lists nodes.
  ///
  /// @Snippet(path: "Tpu_ListNodes")
  public func listNodes(
    request: ListNodesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListNodesResponse {
    try await self.inner.listNodes(request: request, options: options)
  }

  /// Lists nodes.
  ///
  /// @Snippet(path: "Tpu_ListNodes")
  public func listNodes(
    byItem: ListNodesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Node, Swift.Error> {
    let listRpc = { (token: Swift.String) async throws -> GoogleCloudTpuV2.ListNodesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listNodes(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets the details of a node.
  ///
  /// @Snippet(path: "Tpu_GetNode")
  public func getNode(
    request: GetNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.Node {
    try await self.inner.getNode(request: request, options: options)
  }

  /// Creates a node.
  ///
  /// @Snippet(path: "Tpu_CreateNode")
  public func createNode(
    request: CreateNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createNode(request: request, options: options)
  }

  /// Creates a node.
  ///
  /// @Snippet(path: "Tpu_CreateNode")
  public func createNode(
    withPolling: CreateNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Node> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 Node(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.createNode(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 node.
  ///
  /// @Snippet(path: "Tpu_DeleteNode")
  public func deleteNode(
    request: DeleteNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteNode(request: request, options: options)
  }

  /// Deletes a node.
  ///
  /// @Snippet(path: "Tpu_DeleteNode")
  public func deleteNode(
    withPolling: DeleteNodeRequest, 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.deleteNode(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,
    )
  }

  /// Stops a node. This operation is only available with single TPU nodes.
  ///
  /// @Snippet(path: "Tpu_StopNode")
  public func stopNode(
    request: StopNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.stopNode(request: request, options: options)
  }

  /// Stops a node. This operation is only available with single TPU nodes.
  ///
  /// @Snippet(path: "Tpu_StopNode")
  public func stopNode(
    withPolling: StopNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Node> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 Node(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.stopNode(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Node>.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,
    )
  }

  /// Starts a node.
  ///
  /// @Snippet(path: "Tpu_StartNode")
  public func startNode(
    request: StartNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.startNode(request: request, options: options)
  }

  /// Starts a node.
  ///
  /// @Snippet(path: "Tpu_StartNode")
  public func startNode(
    withPolling: StartNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Node> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 Node(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.startNode(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 configurations of a node.
  ///
  /// @Snippet(path: "Tpu_UpdateNode")
  public func updateNode(
    request: UpdateNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateNode(request: request, options: options)
  }

  /// Updates the configurations of a node.
  ///
  /// @Snippet(path: "Tpu_UpdateNode")
  public func updateNode(
    withPolling: UpdateNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<Node> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 Node(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.updateNode(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<Node>.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 queued resources.
  ///
  /// @Snippet(path: "Tpu_ListQueuedResources")
  public func listQueuedResources(
    request: ListQueuedResourcesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListQueuedResourcesResponse {
    try await self.inner.listQueuedResources(request: request, options: options)
  }

  /// Lists queued resources.
  ///
  /// @Snippet(path: "Tpu_ListQueuedResources")
  public func listQueuedResources(
    byItem: ListQueuedResourcesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<QueuedResource, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudTpuV2.ListQueuedResourcesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listQueuedResources(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets details of a queued resource.
  ///
  /// @Snippet(path: "Tpu_GetQueuedResource")
  public func getQueuedResource(
    request: GetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.QueuedResource {
    try await self.inner.getQueuedResource(request: request, options: options)
  }

  /// Creates a QueuedResource TPU instance.
  ///
  /// @Snippet(path: "Tpu_CreateQueuedResource")
  public func createQueuedResource(
    request: CreateQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createQueuedResource(request: request, options: options)
  }

  /// Creates a QueuedResource TPU instance.
  ///
  /// @Snippet(path: "Tpu_CreateQueuedResource")
  public func createQueuedResource(
    withPolling: CreateQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<QueuedResource>.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 QueuedResource(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.createQueuedResource(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<QueuedResource>.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 QueuedResource TPU instance.
  ///
  /// @Snippet(path: "Tpu_DeleteQueuedResource")
  public func deleteQueuedResource(
    request: DeleteQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteQueuedResource(request: request, options: options)
  }

  /// Deletes a QueuedResource TPU instance.
  ///
  /// @Snippet(path: "Tpu_DeleteQueuedResource")
  public func deleteQueuedResource(
    withPolling: DeleteQueuedResourceRequest, 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.deleteQueuedResource(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,
    )
  }

  /// Resets a QueuedResource TPU instance
  ///
  /// @Snippet(path: "Tpu_ResetQueuedResource")
  public func resetQueuedResource(
    request: ResetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.resetQueuedResource(request: request, options: options)
  }

  /// Resets a QueuedResource TPU instance
  ///
  /// @Snippet(path: "Tpu_ResetQueuedResource")
  public func resetQueuedResource(
    withPolling: ResetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<QueuedResource>.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 QueuedResource(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.resetQueuedResource(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<QueuedResource>.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,
    )
  }

  /// Generates the Cloud TPU service identity for the project.
  ///
  /// @Snippet(path: "Tpu_GenerateServiceIdentity")
  public func generateServiceIdentity(
    request: GenerateServiceIdentityRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.GenerateServiceIdentityResponse {
    try await self.inner.generateServiceIdentity(request: request, options: options)
  }

  /// Lists accelerator types supported by this API.
  ///
  /// @Snippet(path: "Tpu_ListAcceleratorTypes")
  public func listAcceleratorTypes(
    request: ListAcceleratorTypesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListAcceleratorTypesResponse {
    try await self.inner.listAcceleratorTypes(request: request, options: options)
  }

  /// Lists accelerator types supported by this API.
  ///
  /// @Snippet(path: "Tpu_ListAcceleratorTypes")
  public func listAcceleratorTypes(
    byItem: ListAcceleratorTypesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<AcceleratorType, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudTpuV2.ListAcceleratorTypesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listAcceleratorTypes(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets AcceleratorType.
  ///
  /// @Snippet(path: "Tpu_GetAcceleratorType")
  public func getAcceleratorType(
    request: GetAcceleratorTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.AcceleratorType {
    try await self.inner.getAcceleratorType(request: request, options: options)
  }

  /// Lists runtime versions supported by this API.
  ///
  /// @Snippet(path: "Tpu_ListRuntimeVersions")
  public func listRuntimeVersions(
    request: ListRuntimeVersionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListRuntimeVersionsResponse {
    try await self.inner.listRuntimeVersions(request: request, options: options)
  }

  /// Lists runtime versions supported by this API.
  ///
  /// @Snippet(path: "Tpu_ListRuntimeVersions")
  public func listRuntimeVersions(
    byItem: ListRuntimeVersionsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RuntimeVersion, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudTpuV2.ListRuntimeVersionsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listRuntimeVersions(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets a runtime version.
  ///
  /// @Snippet(path: "Tpu_GetRuntimeVersion")
  public func getRuntimeVersion(
    request: GetRuntimeVersionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.RuntimeVersion {
    try await self.inner.getRuntimeVersion(request: request, options: options)
  }

  /// Retrieves the guest attributes for the node.
  ///
  /// @Snippet(path: "Tpu_GetGuestAttributes")
  public func getGuestAttributes(
    request: GetGuestAttributesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.GetGuestAttributesResponse {
    try await self.inner.getGuestAttributes(request: request, options: options)
  }

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

  /// Lists information about the supported locations for this service.
  ///
  /// @Snippet(path: "Tpu_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: "Tpu_GetLocation")
  public func getLocation(
    request: GoogleCloudLocation.GetLocationRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudLocation.Location {
    try await self.inner.getLocation(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: "Tpu_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: "Tpu_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: "Tpu_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: "Tpu_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: "Tpu_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 `TpuClient`.
  ///
  /// To mock `TpuClient` change your functions to receive
  /// `some TpuProtocol` or `any TpuProtocol`
  /// and pass a mock implementation in your tests.
  public protocol TpuProtocol {
    /// See `TpuClient.listNodes`.
    func listNodes(request: ListNodesRequest) async throws -> GoogleCloudTpuV2.ListNodesResponse

    /// See `TpuClient.listNodes`.
    func listNodes(
      byItem: ListNodesRequest
    ) throws -> any AsyncSequence<Node, Swift.Error>

    /// See `TpuClient.listNodes`.
    func listNodes(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Node, Swift.Error>

    /// See `TpuClient.getNode`.
    func getNode(request: GetNodeRequest) async throws -> GoogleCloudTpuV2.Node

    /// See `TpuClient.getNode`.
    func getNode(
      name: Swift.String,
    ) async throws -> GoogleCloudTpuV2.Node

    /// See `TpuClient.createNode`.
    func createNode(request: CreateNodeRequest) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.createNode`.
    func createNode(withPolling: CreateNodeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Node>

    /// See `TpuClient.createNode`.
    func createNode(
      parent: Swift.String,
      node: Node?,
      nodeId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<Node>

    /// See `TpuClient.deleteNode`.
    func deleteNode(request: DeleteNodeRequest) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.deleteNode`.
    func deleteNode(withPolling: DeleteNodeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `TpuClient.stopNode`.
    func stopNode(request: StopNodeRequest) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.stopNode`.
    func stopNode(withPolling: StopNodeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Node>

    /// See `TpuClient.startNode`.
    func startNode(request: StartNodeRequest) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.startNode`.
    func startNode(withPolling: StartNodeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Node>

    /// See `TpuClient.updateNode`.
    func updateNode(request: UpdateNodeRequest) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.updateNode`.
    func updateNode(withPolling: UpdateNodeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Node>

    /// See `TpuClient.updateNode`.
    func updateNode(
      node: Node?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<Node>

    /// See `TpuClient.listQueuedResources`.
    func listQueuedResources(request: ListQueuedResourcesRequest) async throws
      -> GoogleCloudTpuV2.ListQueuedResourcesResponse

    /// See `TpuClient.listQueuedResources`.
    func listQueuedResources(
      byItem: ListQueuedResourcesRequest
    ) throws -> any AsyncSequence<QueuedResource, Swift.Error>

    /// See `TpuClient.listQueuedResources`.
    func listQueuedResources(
      parent: Swift.String,
    ) throws -> any AsyncSequence<QueuedResource, Swift.Error>

    /// See `TpuClient.getQueuedResource`.
    func getQueuedResource(request: GetQueuedResourceRequest) async throws
      -> GoogleCloudTpuV2.QueuedResource

    /// See `TpuClient.getQueuedResource`.
    func getQueuedResource(
      name: Swift.String,
    ) async throws -> GoogleCloudTpuV2.QueuedResource

    /// See `TpuClient.createQueuedResource`.
    func createQueuedResource(request: CreateQueuedResourceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `TpuClient.createQueuedResource`.
    func createQueuedResource(withPolling: CreateQueuedResourceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<QueuedResource>

    /// See `TpuClient.createQueuedResource`.
    func createQueuedResource(
      parent: Swift.String,
      queuedResource: QueuedResource?,
      queuedResourceId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource>

    /// See `TpuClient.deleteQueuedResource`.
    func deleteQueuedResource(request: DeleteQueuedResourceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `TpuClient.deleteQueuedResource`.
    func deleteQueuedResource(withPolling: DeleteQueuedResourceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `TpuClient.resetQueuedResource`.
    func resetQueuedResource(request: ResetQueuedResourceRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `TpuClient.resetQueuedResource`.
    func resetQueuedResource(withPolling: ResetQueuedResourceRequest) async throws
      -> any GoogleCloudGax.PollableOperation<QueuedResource>

    /// See `TpuClient.resetQueuedResource`.
    func resetQueuedResource(
      name: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource>

    /// See `TpuClient.generateServiceIdentity`.
    func generateServiceIdentity(request: GenerateServiceIdentityRequest) async throws
      -> GoogleCloudTpuV2.GenerateServiceIdentityResponse

    /// See `TpuClient.listAcceleratorTypes`.
    func listAcceleratorTypes(request: ListAcceleratorTypesRequest) async throws
      -> GoogleCloudTpuV2.ListAcceleratorTypesResponse

    /// See `TpuClient.listAcceleratorTypes`.
    func listAcceleratorTypes(
      byItem: ListAcceleratorTypesRequest
    ) throws -> any AsyncSequence<AcceleratorType, Swift.Error>

    /// See `TpuClient.listAcceleratorTypes`.
    func listAcceleratorTypes(
      parent: Swift.String,
    ) throws -> any AsyncSequence<AcceleratorType, Swift.Error>

    /// See `TpuClient.getAcceleratorType`.
    func getAcceleratorType(request: GetAcceleratorTypeRequest) async throws
      -> GoogleCloudTpuV2.AcceleratorType

    /// See `TpuClient.getAcceleratorType`.
    func getAcceleratorType(
      name: Swift.String,
    ) async throws -> GoogleCloudTpuV2.AcceleratorType

    /// See `TpuClient.listRuntimeVersions`.
    func listRuntimeVersions(request: ListRuntimeVersionsRequest) async throws
      -> GoogleCloudTpuV2.ListRuntimeVersionsResponse

    /// See `TpuClient.listRuntimeVersions`.
    func listRuntimeVersions(
      byItem: ListRuntimeVersionsRequest
    ) throws -> any AsyncSequence<RuntimeVersion, Swift.Error>

    /// See `TpuClient.listRuntimeVersions`.
    func listRuntimeVersions(
      parent: Swift.String,
    ) throws -> any AsyncSequence<RuntimeVersion, Swift.Error>

    /// See `TpuClient.getRuntimeVersion`.
    func getRuntimeVersion(request: GetRuntimeVersionRequest) async throws
      -> GoogleCloudTpuV2.RuntimeVersion

    /// See `TpuClient.getRuntimeVersion`.
    func getRuntimeVersion(
      name: Swift.String,
    ) async throws -> GoogleCloudTpuV2.RuntimeVersion

    /// See `TpuClient.getGuestAttributes`.
    func getGuestAttributes(request: GetGuestAttributesRequest) async throws
      -> GoogleCloudTpuV2.GetGuestAttributesResponse

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

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

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

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

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

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

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

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

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

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

    /// See `TpuClient.listNodes`.
    func listNodes(
      request: ListNodesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.ListNodesResponse

    /// See `TpuClient.listNodes`.
    func listNodes(
      byItem: ListNodesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Node, Swift.Error>

    /// See `TpuClient.getNode`.
    func getNode(
      request: GetNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.Node

    /// See `TpuClient.createNode`.
    func createNode(
      request: CreateNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.createNode`.
    func createNode(
      withPolling: CreateNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Node>

    /// See `TpuClient.deleteNode`.
    func deleteNode(
      request: DeleteNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.deleteNode`.
    func deleteNode(
      withPolling: DeleteNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `TpuClient.stopNode`.
    func stopNode(
      request: StopNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.stopNode`.
    func stopNode(
      withPolling: StopNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Node>

    /// See `TpuClient.startNode`.
    func startNode(
      request: StartNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.startNode`.
    func startNode(
      withPolling: StartNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Node>

    /// See `TpuClient.updateNode`.
    func updateNode(
      request: UpdateNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.updateNode`.
    func updateNode(
      withPolling: UpdateNodeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Node>

    /// See `TpuClient.listQueuedResources`.
    func listQueuedResources(
      request: ListQueuedResourcesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.ListQueuedResourcesResponse

    /// See `TpuClient.listQueuedResources`.
    func listQueuedResources(
      byItem: ListQueuedResourcesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<QueuedResource, Swift.Error>

    /// See `TpuClient.getQueuedResource`.
    func getQueuedResource(
      request: GetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.QueuedResource

    /// See `TpuClient.createQueuedResource`.
    func createQueuedResource(
      request: CreateQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.createQueuedResource`.
    func createQueuedResource(
      withPolling: CreateQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource>

    /// See `TpuClient.deleteQueuedResource`.
    func deleteQueuedResource(
      request: DeleteQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.deleteQueuedResource`.
    func deleteQueuedResource(
      withPolling: DeleteQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `TpuClient.resetQueuedResource`.
    func resetQueuedResource(
      request: ResetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `TpuClient.resetQueuedResource`.
    func resetQueuedResource(
      withPolling: ResetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource>

    /// See `TpuClient.generateServiceIdentity`.
    func generateServiceIdentity(
      request: GenerateServiceIdentityRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.GenerateServiceIdentityResponse

    /// See `TpuClient.listAcceleratorTypes`.
    func listAcceleratorTypes(
      request: ListAcceleratorTypesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.ListAcceleratorTypesResponse

    /// See `TpuClient.listAcceleratorTypes`.
    func listAcceleratorTypes(
      byItem: ListAcceleratorTypesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<AcceleratorType, Swift.Error>

    /// See `TpuClient.getAcceleratorType`.
    func getAcceleratorType(
      request: GetAcceleratorTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.AcceleratorType

    /// See `TpuClient.listRuntimeVersions`.
    func listRuntimeVersions(
      request: ListRuntimeVersionsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.ListRuntimeVersionsResponse

    /// See `TpuClient.listRuntimeVersions`.
    func listRuntimeVersions(
      byItem: ListRuntimeVersionsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<RuntimeVersion, Swift.Error>

    /// See `TpuClient.getRuntimeVersion`.
    func getRuntimeVersion(
      request: GetRuntimeVersionRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.RuntimeVersion

    /// See `TpuClient.getGuestAttributes`.
    func getGuestAttributes(
      request: GetGuestAttributesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudTpuV2.GetGuestAttributesResponse

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

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

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

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

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

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

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

// Default implementations
extension Clients.TpuProtocol {
  public func listNodes(request: ListNodesRequest) async throws
    -> GoogleCloudTpuV2.ListNodesResponse
  {
    try await self.listNodes(request: request, options: .init())
  }

  public func listNodes(
    request: ListNodesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListNodesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listNodes(
    byItem: ListNodesRequest
  ) throws -> any AsyncSequence<Node, Swift.Error> {
    try self.listNodes(byItem: byItem, options: .init())
  }

  public func listNodes(
    byItem: ListNodesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Node, Swift.Error> {
    let listRpc = { (token: Swift.String) async throws -> GoogleCloudTpuV2.ListNodesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getNode(request: GetNodeRequest) async throws -> GoogleCloudTpuV2.Node {
    try await self.getNode(request: request, options: .init())
  }

  public func getNode(
    request: GetNodeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.Node {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getNode(
    name: Swift.String,
  ) async throws -> GoogleCloudTpuV2.Node {
    let request = GetNodeRequest().with {
      $0.name = name
    }
    return try await self.getNode(request: request)
  }

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

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

  public func createNode(withPolling: CreateNodeRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Node>
  {
    try await self.createNode(withPolling: withPolling, options: .init())
  }

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

  public func createNode(
    parent: Swift.String,
    node: Node?,
    nodeId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<Node> {
    let request = CreateNodeRequest().with {
      $0.parent = parent
      $0.node = node
      $0.nodeId = nodeId
    }
    return try await self.createNode(withPolling: request)
  }

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

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

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

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

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

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

  public func stopNode(withPolling: StopNodeRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Node>
  {
    try await self.stopNode(withPolling: withPolling, options: .init())
  }

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

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

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

  public func startNode(withPolling: StartNodeRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Node>
  {
    try await self.startNode(withPolling: withPolling, options: .init())
  }

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

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

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

  public func updateNode(withPolling: UpdateNodeRequest) async throws -> any GoogleCloudGax
    .PollableOperation<Node>
  {
    try await self.updateNode(withPolling: withPolling, options: .init())
  }

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

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

  public func listQueuedResources(request: ListQueuedResourcesRequest) async throws
    -> GoogleCloudTpuV2.ListQueuedResourcesResponse
  {
    try await self.listQueuedResources(request: request, options: .init())
  }

  public func listQueuedResources(
    request: ListQueuedResourcesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListQueuedResourcesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listQueuedResources(
    byItem: ListQueuedResourcesRequest
  ) throws -> any AsyncSequence<QueuedResource, Swift.Error> {
    try self.listQueuedResources(byItem: byItem, options: .init())
  }

  public func listQueuedResources(
    byItem: ListQueuedResourcesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<QueuedResource, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudTpuV2.ListQueuedResourcesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getQueuedResource(request: GetQueuedResourceRequest) async throws
    -> GoogleCloudTpuV2.QueuedResource
  {
    try await self.getQueuedResource(request: request, options: .init())
  }

  public func getQueuedResource(
    request: GetQueuedResourceRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.QueuedResource {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getQueuedResource(
    name: Swift.String,
  ) async throws -> GoogleCloudTpuV2.QueuedResource {
    let request = GetQueuedResourceRequest().with {
      $0.name = name
    }
    return try await self.getQueuedResource(request: request)
  }

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

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

  public func createQueuedResource(withPolling: CreateQueuedResourceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<QueuedResource>
  {
    try await self.createQueuedResource(withPolling: withPolling, options: .init())
  }

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

  public func createQueuedResource(
    parent: Swift.String,
    queuedResource: QueuedResource?,
    queuedResourceId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<QueuedResource> {
    let request = CreateQueuedResourceRequest().with {
      $0.parent = parent
      $0.queuedResource = queuedResource
      $0.queuedResourceId = queuedResourceId
    }
    return try await self.createQueuedResource(withPolling: request)
  }

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

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

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

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

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

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

  public func resetQueuedResource(withPolling: ResetQueuedResourceRequest) async throws
    -> any GoogleCloudGax.PollableOperation<QueuedResource>
  {
    try await self.resetQueuedResource(withPolling: withPolling, options: .init())
  }

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

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

  public func generateServiceIdentity(request: GenerateServiceIdentityRequest) async throws
    -> GoogleCloudTpuV2.GenerateServiceIdentityResponse
  {
    try await self.generateServiceIdentity(request: request, options: .init())
  }

  public func generateServiceIdentity(
    request: GenerateServiceIdentityRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.GenerateServiceIdentityResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listAcceleratorTypes(request: ListAcceleratorTypesRequest) async throws
    -> GoogleCloudTpuV2.ListAcceleratorTypesResponse
  {
    try await self.listAcceleratorTypes(request: request, options: .init())
  }

  public func listAcceleratorTypes(
    request: ListAcceleratorTypesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListAcceleratorTypesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listAcceleratorTypes(
    byItem: ListAcceleratorTypesRequest
  ) throws -> any AsyncSequence<AcceleratorType, Swift.Error> {
    try self.listAcceleratorTypes(byItem: byItem, options: .init())
  }

  public func listAcceleratorTypes(
    byItem: ListAcceleratorTypesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<AcceleratorType, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudTpuV2.ListAcceleratorTypesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getAcceleratorType(request: GetAcceleratorTypeRequest) async throws
    -> GoogleCloudTpuV2.AcceleratorType
  {
    try await self.getAcceleratorType(request: request, options: .init())
  }

  public func getAcceleratorType(
    request: GetAcceleratorTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.AcceleratorType {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getAcceleratorType(
    name: Swift.String,
  ) async throws -> GoogleCloudTpuV2.AcceleratorType {
    let request = GetAcceleratorTypeRequest().with {
      $0.name = name
    }
    return try await self.getAcceleratorType(request: request)
  }

  public func listRuntimeVersions(request: ListRuntimeVersionsRequest) async throws
    -> GoogleCloudTpuV2.ListRuntimeVersionsResponse
  {
    try await self.listRuntimeVersions(request: request, options: .init())
  }

  public func listRuntimeVersions(
    request: ListRuntimeVersionsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.ListRuntimeVersionsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listRuntimeVersions(
    byItem: ListRuntimeVersionsRequest
  ) throws -> any AsyncSequence<RuntimeVersion, Swift.Error> {
    try self.listRuntimeVersions(byItem: byItem, options: .init())
  }

  public func listRuntimeVersions(
    byItem: ListRuntimeVersionsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<RuntimeVersion, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudTpuV2.ListRuntimeVersionsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getRuntimeVersion(request: GetRuntimeVersionRequest) async throws
    -> GoogleCloudTpuV2.RuntimeVersion
  {
    try await self.getRuntimeVersion(request: request, options: .init())
  }

  public func getRuntimeVersion(
    request: GetRuntimeVersionRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.RuntimeVersion {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getRuntimeVersion(
    name: Swift.String,
  ) async throws -> GoogleCloudTpuV2.RuntimeVersion {
    let request = GetRuntimeVersionRequest().with {
      $0.name = name
    }
    return try await self.getRuntimeVersion(request: request)
  }

  public func getGuestAttributes(request: GetGuestAttributesRequest) async throws
    -> GoogleCloudTpuV2.GetGuestAttributesResponse
  {
    try await self.getGuestAttributes(request: request, options: .init())
  }

  public func getGuestAttributes(
    request: GetGuestAttributesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudTpuV2.GetGuestAttributesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  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 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)
  }
}
