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

/// The primary resources offered by this service are EntryGroups, EntryTypes,
/// AspectTypes, Entries and EntryLinks. They collectively let data
/// administrators organize, manage, secure, and catalog data located across
/// cloud projects in their organization in a variety of storage systems,
/// including Cloud Storage and BigQuery.
///
/// @Snippet(path: "CatalogServiceQuickstart")
public class CatalogServiceClient: Clients.CatalogServiceProtocol {
  let inner: any Clients.CatalogServiceStub
  let pollingErrorPolicy: GoogleCloudGax.PollingErrorPolicy
  let pollingBackoffPolicy: GoogleCloudGax.BackoffPolicy

  /// Creates a new `CatalogServiceClient` instance.
  public init(_ options: GoogleCloudGax.ClientOptions = .init()) throws {
    var inner: any Clients.CatalogServiceStub = try Clients.CatalogServiceTransport(options)
    inner = Clients.CatalogServiceRetry(inner, options: options)
    if let logger = options.logger {
      inner = Clients.CatalogServiceLogging(inner, logger: logger)
    }
    self.inner = inner
    self.pollingErrorPolicy = options.pollingErrorPolicy
    self.pollingBackoffPolicy = options.pollingBackoffPolicy
  }

  /// Creates an EntryType.
  ///
  /// @Snippet(path: "CatalogService_CreateEntryType")
  public func createEntryType(
    request: CreateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createEntryType(request: request, options: options)
  }

  /// Creates an EntryType.
  ///
  /// @Snippet(path: "CatalogService_CreateEntryType")
  public func createEntryType(
    withPolling: CreateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<EntryType> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<EntryType>.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 EntryType(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.createEntryType(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<EntryType>.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 an EntryType.
  ///
  /// @Snippet(path: "CatalogService_UpdateEntryType")
  public func updateEntryType(
    request: UpdateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateEntryType(request: request, options: options)
  }

  /// Updates an EntryType.
  ///
  /// @Snippet(path: "CatalogService_UpdateEntryType")
  public func updateEntryType(
    withPolling: UpdateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<EntryType> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<EntryType>.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 EntryType(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.updateEntryType(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<EntryType>.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 EntryType.
  ///
  /// @Snippet(path: "CatalogService_DeleteEntryType")
  public func deleteEntryType(
    request: DeleteEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteEntryType(request: request, options: options)
  }

  /// Deletes an EntryType.
  ///
  /// @Snippet(path: "CatalogService_DeleteEntryType")
  public func deleteEntryType(
    withPolling: DeleteEntryTypeRequest, 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.deleteEntryType(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 EntryType resources in a project and location.
  ///
  /// @Snippet(path: "CatalogService_ListEntryTypes")
  public func listEntryTypes(
    request: ListEntryTypesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListEntryTypesResponse {
    try await self.inner.listEntryTypes(request: request, options: options)
  }

  /// Lists EntryType resources in a project and location.
  ///
  /// @Snippet(path: "CatalogService_ListEntryTypes")
  public func listEntryTypes(
    byItem: ListEntryTypesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<EntryType, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListEntryTypesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listEntryTypes(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets an EntryType.
  ///
  /// @Snippet(path: "CatalogService_GetEntryType")
  public func getEntryType(
    request: GetEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryType {
    try await self.inner.getEntryType(request: request, options: options)
  }

  /// Creates an AspectType.
  ///
  /// @Snippet(path: "CatalogService_CreateAspectType")
  public func createAspectType(
    request: CreateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createAspectType(request: request, options: options)
  }

  /// Creates an AspectType.
  ///
  /// @Snippet(path: "CatalogService_CreateAspectType")
  public func createAspectType(
    withPolling: CreateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<AspectType> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<AspectType>.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 AspectType(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.createAspectType(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<AspectType>.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 an AspectType.
  ///
  /// @Snippet(path: "CatalogService_UpdateAspectType")
  public func updateAspectType(
    request: UpdateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateAspectType(request: request, options: options)
  }

  /// Updates an AspectType.
  ///
  /// @Snippet(path: "CatalogService_UpdateAspectType")
  public func updateAspectType(
    withPolling: UpdateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<AspectType> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<AspectType>.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 AspectType(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.updateAspectType(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<AspectType>.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 AspectType.
  ///
  /// @Snippet(path: "CatalogService_DeleteAspectType")
  public func deleteAspectType(
    request: DeleteAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteAspectType(request: request, options: options)
  }

  /// Deletes an AspectType.
  ///
  /// @Snippet(path: "CatalogService_DeleteAspectType")
  public func deleteAspectType(
    withPolling: DeleteAspectTypeRequest, 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.deleteAspectType(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 AspectType resources in a project and location.
  ///
  /// @Snippet(path: "CatalogService_ListAspectTypes")
  public func listAspectTypes(
    request: ListAspectTypesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListAspectTypesResponse {
    try await self.inner.listAspectTypes(request: request, options: options)
  }

  /// Lists AspectType resources in a project and location.
  ///
  /// @Snippet(path: "CatalogService_ListAspectTypes")
  public func listAspectTypes(
    byItem: ListAspectTypesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<AspectType, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListAspectTypesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listAspectTypes(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets an AspectType.
  ///
  /// @Snippet(path: "CatalogService_GetAspectType")
  public func getAspectType(
    request: GetAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.AspectType {
    try await self.inner.getAspectType(request: request, options: options)
  }

  /// Creates an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_CreateEntryGroup")
  public func createEntryGroup(
    request: CreateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createEntryGroup(request: request, options: options)
  }

  /// Creates an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_CreateEntryGroup")
  public func createEntryGroup(
    withPolling: CreateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<EntryGroup>.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 EntryGroup(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.createEntryGroup(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<EntryGroup>.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 an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_UpdateEntryGroup")
  public func updateEntryGroup(
    request: UpdateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateEntryGroup(request: request, options: options)
  }

  /// Updates an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_UpdateEntryGroup")
  public func updateEntryGroup(
    withPolling: UpdateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<EntryGroup>.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 EntryGroup(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.updateEntryGroup(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<EntryGroup>.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 EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_DeleteEntryGroup")
  public func deleteEntryGroup(
    request: DeleteEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteEntryGroup(request: request, options: options)
  }

  /// Deletes an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_DeleteEntryGroup")
  public func deleteEntryGroup(
    withPolling: DeleteEntryGroupRequest, 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.deleteEntryGroup(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 EntryGroup resources in a project and location.
  ///
  /// @Snippet(path: "CatalogService_ListEntryGroups")
  public func listEntryGroups(
    request: ListEntryGroupsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListEntryGroupsResponse {
    try await self.inner.listEntryGroups(request: request, options: options)
  }

  /// Lists EntryGroup resources in a project and location.
  ///
  /// @Snippet(path: "CatalogService_ListEntryGroups")
  public func listEntryGroups(
    byItem: ListEntryGroupsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<EntryGroup, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListEntryGroupsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listEntryGroups(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_GetEntryGroup")
  public func getEntryGroup(
    request: GetEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryGroup {
    try await self.inner.getEntryGroup(request: request, options: options)
  }

  /// Creates an Entry.
  ///
  /// @Snippet(path: "CatalogService_CreateEntry")
  public func createEntry(
    request: CreateEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.inner.createEntry(request: request, options: options)
  }

  /// Updates an Entry.
  ///
  /// @Snippet(path: "CatalogService_UpdateEntry")
  public func updateEntry(
    request: UpdateEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.inner.updateEntry(request: request, options: options)
  }

  /// Deletes an Entry.
  ///
  /// @Snippet(path: "CatalogService_DeleteEntry")
  public func deleteEntry(
    request: DeleteEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.inner.deleteEntry(request: request, options: options)
  }

  /// Lists Entries within an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_ListEntries")
  public func listEntries(
    request: ListEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListEntriesResponse {
    try await self.inner.listEntries(request: request, options: options)
  }

  /// Lists Entries within an EntryGroup.
  ///
  /// @Snippet(path: "CatalogService_ListEntries")
  public func listEntries(
    byItem: ListEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Entry, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListEntriesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listEntries(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Gets an Entry.
  ///
  /// @Snippet(path: "CatalogService_GetEntry")
  public func getEntry(
    request: GetEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.inner.getEntry(request: request, options: options)
  }

  /// Looks up an entry by name using the permission on the source system.
  ///
  /// @Snippet(path: "CatalogService_LookupEntry")
  public func lookupEntry(
    request: LookupEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.inner.lookupEntry(request: request, options: options)
  }

  /// Modifies an entry using the permission on the source system.
  ///
  /// @Snippet(path: "CatalogService_ModifyEntry")
  public func modifyEntry(
    request: ModifyEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.inner.modifyEntry(request: request, options: options)
  }

  /// Searches for Entries matching the given query and scope.
  ///
  /// @Snippet(path: "CatalogService_SearchEntries")
  public func searchEntries(
    request: SearchEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.SearchEntriesResponse {
    try await self.inner.searchEntries(request: request, options: options)
  }

  /// Searches for Entries matching the given query and scope.
  ///
  /// @Snippet(path: "CatalogService_SearchEntries")
  public func searchEntries(
    byItem: SearchEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<SearchEntriesResult, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.SearchEntriesResponse in
      var request = byItem
      request.pageToken = token
      return try await self.searchEntries(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Creates a metadata job. For example, use a metadata job to import metadata
  /// from a third-party system into Dataplex Universal Catalog.
  ///
  /// @Snippet(path: "CatalogService_CreateMetadataJob")
  public func createMetadataJob(
    request: CreateMetadataJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createMetadataJob(request: request, options: options)
  }

  /// Creates a metadata job. For example, use a metadata job to import metadata
  /// from a third-party system into Dataplex Universal Catalog.
  ///
  /// @Snippet(path: "CatalogService_CreateMetadataJob")
  public func createMetadataJob(
    withPolling: CreateMetadataJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MetadataJob> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MetadataJob>.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 MetadataJob(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.createMetadataJob(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MetadataJob>.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 metadata job.
  ///
  /// @Snippet(path: "CatalogService_GetMetadataJob")
  public func getMetadataJob(
    request: GetMetadataJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.MetadataJob {
    try await self.inner.getMetadataJob(request: request, options: options)
  }

  /// Lists metadata jobs.
  ///
  /// @Snippet(path: "CatalogService_ListMetadataJobs")
  public func listMetadataJobs(
    request: ListMetadataJobsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListMetadataJobsResponse {
    try await self.inner.listMetadataJobs(request: request, options: options)
  }

  /// Lists metadata jobs.
  ///
  /// @Snippet(path: "CatalogService_ListMetadataJobs")
  public func listMetadataJobs(
    byItem: ListMetadataJobsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MetadataJob, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListMetadataJobsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listMetadataJobs(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Cancels a metadata job.
  ///
  /// If you cancel a metadata import job that is in progress, the changes in the
  /// job might be partially applied. We recommend that you reset the state of
  /// the entry groups in your project by running another metadata job that
  /// reverts the changes from the canceled job.
  ///
  /// @Snippet(path: "CatalogService_CancelMetadataJob")
  public func cancelMetadataJob(
    request: CancelMetadataJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws {
    try await self.inner.cancelMetadataJob(request: request, options: options)
  }

  /// Creates an Entry Link.
  ///
  /// @Snippet(path: "CatalogService_CreateEntryLink")
  public func createEntryLink(
    request: CreateEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    try await self.inner.createEntryLink(request: request, options: options)
  }

  /// Updates an Entry Link.
  ///
  /// @Snippet(path: "CatalogService_UpdateEntryLink")
  public func updateEntryLink(
    request: UpdateEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    try await self.inner.updateEntryLink(request: request, options: options)
  }

  /// Deletes an Entry Link.
  ///
  /// @Snippet(path: "CatalogService_DeleteEntryLink")
  public func deleteEntryLink(
    request: DeleteEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    try await self.inner.deleteEntryLink(request: request, options: options)
  }

  /// Looks up Entry Links referencing the specified Entry.
  ///
  /// @Snippet(path: "CatalogService_LookupEntryLinks")
  public func lookupEntryLinks(
    request: LookupEntryLinksRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.LookupEntryLinksResponse {
    try await self.inner.lookupEntryLinks(request: request, options: options)
  }

  /// Looks up Entry Links referencing the specified Entry.
  ///
  /// @Snippet(path: "CatalogService_LookupEntryLinks")
  public func lookupEntryLinks(
    byItem: LookupEntryLinksRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<EntryLink, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.LookupEntryLinksResponse in
      var request = byItem
      request.pageToken = token
      return try await self.lookupEntryLinks(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Looks up LLM Context for the specified resources.
  ///
  /// @Snippet(path: "CatalogService_LookupContext")
  public func lookupContext(
    request: LookupContextRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.LookupContextResponse {
    try await self.inner.lookupContext(request: request, options: options)
  }

  /// Gets an Entry Link.
  ///
  /// @Snippet(path: "CatalogService_GetEntryLink")
  public func getEntryLink(
    request: GetEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    try await self.inner.getEntryLink(request: request, options: options)
  }

  /// Creates a MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_CreateMetadataFeed")
  public func createMetadataFeed(
    request: CreateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.createMetadataFeed(request: request, options: options)
  }

  /// Creates a MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_CreateMetadataFeed")
  public func createMetadataFeed(
    withPolling: CreateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MetadataFeed>.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 MetadataFeed(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.createMetadataFeed(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MetadataFeed>.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 MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_GetMetadataFeed")
  public func getMetadataFeed(
    request: GetMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.MetadataFeed {
    try await self.inner.getMetadataFeed(request: request, options: options)
  }

  /// Retrieve a list of MetadataFeeds.
  ///
  /// @Snippet(path: "CatalogService_ListMetadataFeeds")
  public func listMetadataFeeds(
    request: ListMetadataFeedsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListMetadataFeedsResponse {
    try await self.inner.listMetadataFeeds(request: request, options: options)
  }

  /// Retrieve a list of MetadataFeeds.
  ///
  /// @Snippet(path: "CatalogService_ListMetadataFeeds")
  public func listMetadataFeeds(
    byItem: ListMetadataFeedsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MetadataFeed, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListMetadataFeedsResponse in
      var request = byItem
      request.pageToken = token
      return try await self.listMetadataFeeds(request: request, options: options)
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  /// Deletes a MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_DeleteMetadataFeed")
  public func deleteMetadataFeed(
    request: DeleteMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.deleteMetadataFeed(request: request, options: options)
  }

  /// Deletes a MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_DeleteMetadataFeed")
  public func deleteMetadataFeed(
    withPolling: DeleteMetadataFeedRequest, 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.deleteMetadataFeed(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,
    )
  }

  /// Updates a MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_UpdateMetadataFeed")
  public func updateMetadataFeed(
    request: UpdateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleLongRunning.Operation {
    try await self.inner.updateMetadataFeed(request: request, options: options)
  }

  /// Updates a MetadataFeed.
  ///
  /// @Snippet(path: "CatalogService_UpdateMetadataFeed")
  public func updateMetadataFeed(
    withPolling: UpdateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed> {
    let extractStatus = {
      (op: GoogleLongRunning.Operation) throws
        -> GoogleCloudGax._PollableOperationImpl<MetadataFeed>.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 MetadataFeed(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.updateMetadataFeed(request: withPolling, options: options)
    let initialState = try extractStatus(rawOp)
    let poll = { () async throws -> GoogleCloudGax._PollableOperationImpl<MetadataFeed>.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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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: "CatalogService_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 `CatalogServiceClient`.
  ///
  /// To mock `CatalogServiceClient` change your functions to receive
  /// `some CatalogServiceProtocol` or `any CatalogServiceProtocol`
  /// and pass a mock implementation in your tests.
  public protocol CatalogServiceProtocol {
    /// See `CatalogServiceClient.createEntryType`.
    func createEntryType(request: CreateEntryTypeRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createEntryType`.
    func createEntryType(withPolling: CreateEntryTypeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<EntryType>

    /// See `CatalogServiceClient.createEntryType`.
    func createEntryType(
      parent: Swift.String,
      entryType: EntryType?,
      entryTypeId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryType>

    /// See `CatalogServiceClient.updateEntryType`.
    func updateEntryType(request: UpdateEntryTypeRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateEntryType`.
    func updateEntryType(withPolling: UpdateEntryTypeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<EntryType>

    /// See `CatalogServiceClient.updateEntryType`.
    func updateEntryType(
      entryType: EntryType?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryType>

    /// See `CatalogServiceClient.deleteEntryType`.
    func deleteEntryType(request: DeleteEntryTypeRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteEntryType`.
    func deleteEntryType(withPolling: DeleteEntryTypeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `CatalogServiceClient.listEntryTypes`.
    func listEntryTypes(request: ListEntryTypesRequest) async throws
      -> GoogleCloudDataplexV1.ListEntryTypesResponse

    /// See `CatalogServiceClient.listEntryTypes`.
    func listEntryTypes(
      byItem: ListEntryTypesRequest
    ) throws -> any AsyncSequence<EntryType, Swift.Error>

    /// See `CatalogServiceClient.listEntryTypes`.
    func listEntryTypes(
      parent: Swift.String,
    ) throws -> any AsyncSequence<EntryType, Swift.Error>

    /// See `CatalogServiceClient.getEntryType`.
    func getEntryType(request: GetEntryTypeRequest) async throws -> GoogleCloudDataplexV1.EntryType

    /// See `CatalogServiceClient.getEntryType`.
    func getEntryType(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.EntryType

    /// See `CatalogServiceClient.createAspectType`.
    func createAspectType(request: CreateAspectTypeRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createAspectType`.
    func createAspectType(withPolling: CreateAspectTypeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<AspectType>

    /// See `CatalogServiceClient.createAspectType`.
    func createAspectType(
      parent: Swift.String,
      aspectType: AspectType?,
      aspectTypeId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<AspectType>

    /// See `CatalogServiceClient.updateAspectType`.
    func updateAspectType(request: UpdateAspectTypeRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateAspectType`.
    func updateAspectType(withPolling: UpdateAspectTypeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<AspectType>

    /// See `CatalogServiceClient.updateAspectType`.
    func updateAspectType(
      aspectType: AspectType?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<AspectType>

    /// See `CatalogServiceClient.deleteAspectType`.
    func deleteAspectType(request: DeleteAspectTypeRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteAspectType`.
    func deleteAspectType(withPolling: DeleteAspectTypeRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `CatalogServiceClient.listAspectTypes`.
    func listAspectTypes(request: ListAspectTypesRequest) async throws
      -> GoogleCloudDataplexV1.ListAspectTypesResponse

    /// See `CatalogServiceClient.listAspectTypes`.
    func listAspectTypes(
      byItem: ListAspectTypesRequest
    ) throws -> any AsyncSequence<AspectType, Swift.Error>

    /// See `CatalogServiceClient.listAspectTypes`.
    func listAspectTypes(
      parent: Swift.String,
    ) throws -> any AsyncSequence<AspectType, Swift.Error>

    /// See `CatalogServiceClient.getAspectType`.
    func getAspectType(request: GetAspectTypeRequest) async throws
      -> GoogleCloudDataplexV1.AspectType

    /// See `CatalogServiceClient.getAspectType`.
    func getAspectType(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.AspectType

    /// See `CatalogServiceClient.createEntryGroup`.
    func createEntryGroup(request: CreateEntryGroupRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createEntryGroup`.
    func createEntryGroup(withPolling: CreateEntryGroupRequest) async throws -> any GoogleCloudGax
      .PollableOperation<EntryGroup>

    /// See `CatalogServiceClient.createEntryGroup`.
    func createEntryGroup(
      parent: Swift.String,
      entryGroup: EntryGroup?,
      entryGroupId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup>

    /// See `CatalogServiceClient.updateEntryGroup`.
    func updateEntryGroup(request: UpdateEntryGroupRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateEntryGroup`.
    func updateEntryGroup(withPolling: UpdateEntryGroupRequest) async throws -> any GoogleCloudGax
      .PollableOperation<EntryGroup>

    /// See `CatalogServiceClient.updateEntryGroup`.
    func updateEntryGroup(
      entryGroup: EntryGroup?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup>

    /// See `CatalogServiceClient.deleteEntryGroup`.
    func deleteEntryGroup(request: DeleteEntryGroupRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteEntryGroup`.
    func deleteEntryGroup(withPolling: DeleteEntryGroupRequest) async throws -> any GoogleCloudGax
      .PollableOperation<Void>

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

    /// See `CatalogServiceClient.listEntryGroups`.
    func listEntryGroups(request: ListEntryGroupsRequest) async throws
      -> GoogleCloudDataplexV1.ListEntryGroupsResponse

    /// See `CatalogServiceClient.listEntryGroups`.
    func listEntryGroups(
      byItem: ListEntryGroupsRequest
    ) throws -> any AsyncSequence<EntryGroup, Swift.Error>

    /// See `CatalogServiceClient.listEntryGroups`.
    func listEntryGroups(
      parent: Swift.String,
    ) throws -> any AsyncSequence<EntryGroup, Swift.Error>

    /// See `CatalogServiceClient.getEntryGroup`.
    func getEntryGroup(request: GetEntryGroupRequest) async throws
      -> GoogleCloudDataplexV1.EntryGroup

    /// See `CatalogServiceClient.getEntryGroup`.
    func getEntryGroup(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.EntryGroup

    /// See `CatalogServiceClient.createEntry`.
    func createEntry(request: CreateEntryRequest) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.createEntry`.
    func createEntry(
      parent: Swift.String,
      entry: Entry?,
      entryId: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.updateEntry`.
    func updateEntry(request: UpdateEntryRequest) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.updateEntry`.
    func updateEntry(
      entry: Entry?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.deleteEntry`.
    func deleteEntry(request: DeleteEntryRequest) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.deleteEntry`.
    func deleteEntry(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.listEntries`.
    func listEntries(request: ListEntriesRequest) async throws
      -> GoogleCloudDataplexV1.ListEntriesResponse

    /// See `CatalogServiceClient.listEntries`.
    func listEntries(
      byItem: ListEntriesRequest
    ) throws -> any AsyncSequence<Entry, Swift.Error>

    /// See `CatalogServiceClient.listEntries`.
    func listEntries(
      parent: Swift.String,
    ) throws -> any AsyncSequence<Entry, Swift.Error>

    /// See `CatalogServiceClient.getEntry`.
    func getEntry(request: GetEntryRequest) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.getEntry`.
    func getEntry(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.lookupEntry`.
    func lookupEntry(request: LookupEntryRequest) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.modifyEntry`.
    func modifyEntry(request: ModifyEntryRequest) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.searchEntries`.
    func searchEntries(request: SearchEntriesRequest) async throws
      -> GoogleCloudDataplexV1.SearchEntriesResponse

    /// See `CatalogServiceClient.searchEntries`.
    func searchEntries(
      byItem: SearchEntriesRequest
    ) throws -> any AsyncSequence<SearchEntriesResult, Swift.Error>

    /// See `CatalogServiceClient.searchEntries`.
    func searchEntries(
      name: Swift.String,
      query: Swift.String,
    ) throws -> any AsyncSequence<SearchEntriesResult, Swift.Error>

    /// See `CatalogServiceClient.createMetadataJob`.
    func createMetadataJob(request: CreateMetadataJobRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createMetadataJob`.
    func createMetadataJob(withPolling: CreateMetadataJobRequest) async throws -> any GoogleCloudGax
      .PollableOperation<MetadataJob>

    /// See `CatalogServiceClient.createMetadataJob`.
    func createMetadataJob(
      parent: Swift.String,
      metadataJob: MetadataJob?,
      metadataJobId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<MetadataJob>

    /// See `CatalogServiceClient.getMetadataJob`.
    func getMetadataJob(request: GetMetadataJobRequest) async throws
      -> GoogleCloudDataplexV1.MetadataJob

    /// See `CatalogServiceClient.getMetadataJob`.
    func getMetadataJob(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.MetadataJob

    /// See `CatalogServiceClient.listMetadataJobs`.
    func listMetadataJobs(request: ListMetadataJobsRequest) async throws
      -> GoogleCloudDataplexV1.ListMetadataJobsResponse

    /// See `CatalogServiceClient.listMetadataJobs`.
    func listMetadataJobs(
      byItem: ListMetadataJobsRequest
    ) throws -> any AsyncSequence<MetadataJob, Swift.Error>

    /// See `CatalogServiceClient.listMetadataJobs`.
    func listMetadataJobs(
      parent: Swift.String,
    ) throws -> any AsyncSequence<MetadataJob, Swift.Error>

    /// See `CatalogServiceClient.cancelMetadataJob`.
    func cancelMetadataJob(request: CancelMetadataJobRequest) async throws

    /// See `CatalogServiceClient.cancelMetadataJob`.
    func cancelMetadataJob(
      name: Swift.String,
    ) async throws

    /// See `CatalogServiceClient.createEntryLink`.
    func createEntryLink(request: CreateEntryLinkRequest) async throws
      -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.createEntryLink`.
    func createEntryLink(
      parent: Swift.String,
      entryLink: EntryLink?,
      entryLinkId: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.updateEntryLink`.
    func updateEntryLink(request: UpdateEntryLinkRequest) async throws
      -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.updateEntryLink`.
    func updateEntryLink(
      entryLink: EntryLink?,
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.deleteEntryLink`.
    func deleteEntryLink(request: DeleteEntryLinkRequest) async throws
      -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.deleteEntryLink`.
    func deleteEntryLink(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.lookupEntryLinks`.
    func lookupEntryLinks(request: LookupEntryLinksRequest) async throws
      -> GoogleCloudDataplexV1.LookupEntryLinksResponse

    /// See `CatalogServiceClient.lookupEntryLinks`.
    func lookupEntryLinks(
      byItem: LookupEntryLinksRequest
    ) throws -> any AsyncSequence<EntryLink, Swift.Error>

    /// See `CatalogServiceClient.lookupContext`.
    func lookupContext(request: LookupContextRequest) async throws
      -> GoogleCloudDataplexV1.LookupContextResponse

    /// See `CatalogServiceClient.getEntryLink`.
    func getEntryLink(request: GetEntryLinkRequest) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.getEntryLink`.
    func getEntryLink(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.createMetadataFeed`.
    func createMetadataFeed(request: CreateMetadataFeedRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createMetadataFeed`.
    func createMetadataFeed(withPolling: CreateMetadataFeedRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MetadataFeed>

    /// See `CatalogServiceClient.createMetadataFeed`.
    func createMetadataFeed(
      parent: Swift.String,
      metadataFeed: MetadataFeed?,
      metadataFeedId: Swift.String,
    ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed>

    /// See `CatalogServiceClient.getMetadataFeed`.
    func getMetadataFeed(request: GetMetadataFeedRequest) async throws
      -> GoogleCloudDataplexV1.MetadataFeed

    /// See `CatalogServiceClient.getMetadataFeed`.
    func getMetadataFeed(
      name: Swift.String,
    ) async throws -> GoogleCloudDataplexV1.MetadataFeed

    /// See `CatalogServiceClient.listMetadataFeeds`.
    func listMetadataFeeds(request: ListMetadataFeedsRequest) async throws
      -> GoogleCloudDataplexV1.ListMetadataFeedsResponse

    /// See `CatalogServiceClient.listMetadataFeeds`.
    func listMetadataFeeds(
      byItem: ListMetadataFeedsRequest
    ) throws -> any AsyncSequence<MetadataFeed, Swift.Error>

    /// See `CatalogServiceClient.listMetadataFeeds`.
    func listMetadataFeeds(
      parent: Swift.String,
    ) throws -> any AsyncSequence<MetadataFeed, Swift.Error>

    /// See `CatalogServiceClient.deleteMetadataFeed`.
    func deleteMetadataFeed(request: DeleteMetadataFeedRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteMetadataFeed`.
    func deleteMetadataFeed(withPolling: DeleteMetadataFeedRequest) async throws
      -> any GoogleCloudGax.PollableOperation<Void>

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

    /// See `CatalogServiceClient.updateMetadataFeed`.
    func updateMetadataFeed(request: UpdateMetadataFeedRequest) async throws
      -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateMetadataFeed`.
    func updateMetadataFeed(withPolling: UpdateMetadataFeedRequest) async throws
      -> any GoogleCloudGax.PollableOperation<MetadataFeed>

    /// See `CatalogServiceClient.updateMetadataFeed`.
    func updateMetadataFeed(
      metadataFeed: MetadataFeed?,
      updateMask: GoogleCloudWkt.FieldMask?,
    ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed>

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// See `CatalogServiceClient.createEntryType`.
    func createEntryType(
      request: CreateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createEntryType`.
    func createEntryType(
      withPolling: CreateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryType>

    /// See `CatalogServiceClient.updateEntryType`.
    func updateEntryType(
      request: UpdateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateEntryType`.
    func updateEntryType(
      withPolling: UpdateEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryType>

    /// See `CatalogServiceClient.deleteEntryType`.
    func deleteEntryType(
      request: DeleteEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteEntryType`.
    func deleteEntryType(
      withPolling: DeleteEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `CatalogServiceClient.listEntryTypes`.
    func listEntryTypes(
      request: ListEntryTypesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.ListEntryTypesResponse

    /// See `CatalogServiceClient.listEntryTypes`.
    func listEntryTypes(
      byItem: ListEntryTypesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<EntryType, Swift.Error>

    /// See `CatalogServiceClient.getEntryType`.
    func getEntryType(
      request: GetEntryTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.EntryType

    /// See `CatalogServiceClient.createAspectType`.
    func createAspectType(
      request: CreateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createAspectType`.
    func createAspectType(
      withPolling: CreateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<AspectType>

    /// See `CatalogServiceClient.updateAspectType`.
    func updateAspectType(
      request: UpdateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateAspectType`.
    func updateAspectType(
      withPolling: UpdateAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<AspectType>

    /// See `CatalogServiceClient.deleteAspectType`.
    func deleteAspectType(
      request: DeleteAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteAspectType`.
    func deleteAspectType(
      withPolling: DeleteAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `CatalogServiceClient.listAspectTypes`.
    func listAspectTypes(
      request: ListAspectTypesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.ListAspectTypesResponse

    /// See `CatalogServiceClient.listAspectTypes`.
    func listAspectTypes(
      byItem: ListAspectTypesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<AspectType, Swift.Error>

    /// See `CatalogServiceClient.getAspectType`.
    func getAspectType(
      request: GetAspectTypeRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.AspectType

    /// See `CatalogServiceClient.createEntryGroup`.
    func createEntryGroup(
      request: CreateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createEntryGroup`.
    func createEntryGroup(
      withPolling: CreateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup>

    /// See `CatalogServiceClient.updateEntryGroup`.
    func updateEntryGroup(
      request: UpdateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateEntryGroup`.
    func updateEntryGroup(
      withPolling: UpdateEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup>

    /// See `CatalogServiceClient.deleteEntryGroup`.
    func deleteEntryGroup(
      request: DeleteEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteEntryGroup`.
    func deleteEntryGroup(
      withPolling: DeleteEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `CatalogServiceClient.listEntryGroups`.
    func listEntryGroups(
      request: ListEntryGroupsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.ListEntryGroupsResponse

    /// See `CatalogServiceClient.listEntryGroups`.
    func listEntryGroups(
      byItem: ListEntryGroupsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<EntryGroup, Swift.Error>

    /// See `CatalogServiceClient.getEntryGroup`.
    func getEntryGroup(
      request: GetEntryGroupRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.EntryGroup

    /// See `CatalogServiceClient.createEntry`.
    func createEntry(
      request: CreateEntryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.updateEntry`.
    func updateEntry(
      request: UpdateEntryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.deleteEntry`.
    func deleteEntry(
      request: DeleteEntryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.listEntries`.
    func listEntries(
      request: ListEntriesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.ListEntriesResponse

    /// See `CatalogServiceClient.listEntries`.
    func listEntries(
      byItem: ListEntriesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<Entry, Swift.Error>

    /// See `CatalogServiceClient.getEntry`.
    func getEntry(
      request: GetEntryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.lookupEntry`.
    func lookupEntry(
      request: LookupEntryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.modifyEntry`.
    func modifyEntry(
      request: ModifyEntryRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.Entry

    /// See `CatalogServiceClient.searchEntries`.
    func searchEntries(
      request: SearchEntriesRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.SearchEntriesResponse

    /// See `CatalogServiceClient.searchEntries`.
    func searchEntries(
      byItem: SearchEntriesRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<SearchEntriesResult, Swift.Error>

    /// See `CatalogServiceClient.createMetadataJob`.
    func createMetadataJob(
      request: CreateMetadataJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createMetadataJob`.
    func createMetadataJob(
      withPolling: CreateMetadataJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MetadataJob>

    /// See `CatalogServiceClient.getMetadataJob`.
    func getMetadataJob(
      request: GetMetadataJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.MetadataJob

    /// See `CatalogServiceClient.listMetadataJobs`.
    func listMetadataJobs(
      request: ListMetadataJobsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.ListMetadataJobsResponse

    /// See `CatalogServiceClient.listMetadataJobs`.
    func listMetadataJobs(
      byItem: ListMetadataJobsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<MetadataJob, Swift.Error>

    /// See `CatalogServiceClient.cancelMetadataJob`.
    func cancelMetadataJob(
      request: CancelMetadataJobRequest, options: GoogleCloudGax.RequestOptions
    ) async throws

    /// See `CatalogServiceClient.createEntryLink`.
    func createEntryLink(
      request: CreateEntryLinkRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.updateEntryLink`.
    func updateEntryLink(
      request: UpdateEntryLinkRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.deleteEntryLink`.
    func deleteEntryLink(
      request: DeleteEntryLinkRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.lookupEntryLinks`.
    func lookupEntryLinks(
      request: LookupEntryLinksRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.LookupEntryLinksResponse

    /// See `CatalogServiceClient.lookupEntryLinks`.
    func lookupEntryLinks(
      byItem: LookupEntryLinksRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<EntryLink, Swift.Error>

    /// See `CatalogServiceClient.lookupContext`.
    func lookupContext(
      request: LookupContextRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.LookupContextResponse

    /// See `CatalogServiceClient.getEntryLink`.
    func getEntryLink(
      request: GetEntryLinkRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.EntryLink

    /// See `CatalogServiceClient.createMetadataFeed`.
    func createMetadataFeed(
      request: CreateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.createMetadataFeed`.
    func createMetadataFeed(
      withPolling: CreateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed>

    /// See `CatalogServiceClient.getMetadataFeed`.
    func getMetadataFeed(
      request: GetMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.MetadataFeed

    /// See `CatalogServiceClient.listMetadataFeeds`.
    func listMetadataFeeds(
      request: ListMetadataFeedsRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleCloudDataplexV1.ListMetadataFeedsResponse

    /// See `CatalogServiceClient.listMetadataFeeds`.
    func listMetadataFeeds(
      byItem: ListMetadataFeedsRequest, options: GoogleCloudGax.RequestOptions
    ) throws -> any AsyncSequence<MetadataFeed, Swift.Error>

    /// See `CatalogServiceClient.deleteMetadataFeed`.
    func deleteMetadataFeed(
      request: DeleteMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.deleteMetadataFeed`.
    func deleteMetadataFeed(
      withPolling: DeleteMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<Void>

    /// See `CatalogServiceClient.updateMetadataFeed`.
    func updateMetadataFeed(
      request: UpdateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> GoogleLongRunning.Operation

    /// See `CatalogServiceClient.updateMetadataFeed`.
    func updateMetadataFeed(
      withPolling: UpdateMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
    ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed>

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

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

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

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

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

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

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

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

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

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

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

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

  public func createEntryType(withPolling: CreateEntryTypeRequest) async throws
    -> any GoogleCloudGax.PollableOperation<EntryType>
  {
    try await self.createEntryType(withPolling: withPolling, options: .init())
  }

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

  public func createEntryType(
    parent: Swift.String,
    entryType: EntryType?,
    entryTypeId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<EntryType> {
    let request = CreateEntryTypeRequest().with {
      $0.parent = parent
      $0.entryType = entryType
      $0.entryTypeId = entryTypeId
    }
    return try await self.createEntryType(withPolling: request)
  }

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

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

  public func updateEntryType(withPolling: UpdateEntryTypeRequest) async throws
    -> any GoogleCloudGax.PollableOperation<EntryType>
  {
    try await self.updateEntryType(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

  public func listEntryTypes(request: ListEntryTypesRequest) async throws
    -> GoogleCloudDataplexV1.ListEntryTypesResponse
  {
    try await self.listEntryTypes(request: request, options: .init())
  }

  public func listEntryTypes(
    request: ListEntryTypesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListEntryTypesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listEntryTypes(
    byItem: ListEntryTypesRequest
  ) throws -> any AsyncSequence<EntryType, Swift.Error> {
    try self.listEntryTypes(byItem: byItem, options: .init())
  }

  public func listEntryTypes(
    byItem: ListEntryTypesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<EntryType, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListEntryTypesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getEntryType(request: GetEntryTypeRequest) async throws
    -> GoogleCloudDataplexV1.EntryType
  {
    try await self.getEntryType(request: request, options: .init())
  }

  public func getEntryType(
    request: GetEntryTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryType {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getEntryType(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.EntryType {
    let request = GetEntryTypeRequest().with {
      $0.name = name
    }
    return try await self.getEntryType(request: request)
  }

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

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

  public func createAspectType(withPolling: CreateAspectTypeRequest) async throws
    -> any GoogleCloudGax.PollableOperation<AspectType>
  {
    try await self.createAspectType(withPolling: withPolling, options: .init())
  }

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

  public func createAspectType(
    parent: Swift.String,
    aspectType: AspectType?,
    aspectTypeId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<AspectType> {
    let request = CreateAspectTypeRequest().with {
      $0.parent = parent
      $0.aspectType = aspectType
      $0.aspectTypeId = aspectTypeId
    }
    return try await self.createAspectType(withPolling: request)
  }

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

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

  public func updateAspectType(withPolling: UpdateAspectTypeRequest) async throws
    -> any GoogleCloudGax.PollableOperation<AspectType>
  {
    try await self.updateAspectType(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

  public func listAspectTypes(request: ListAspectTypesRequest) async throws
    -> GoogleCloudDataplexV1.ListAspectTypesResponse
  {
    try await self.listAspectTypes(request: request, options: .init())
  }

  public func listAspectTypes(
    request: ListAspectTypesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListAspectTypesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listAspectTypes(
    byItem: ListAspectTypesRequest
  ) throws -> any AsyncSequence<AspectType, Swift.Error> {
    try self.listAspectTypes(byItem: byItem, options: .init())
  }

  public func listAspectTypes(
    byItem: ListAspectTypesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<AspectType, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListAspectTypesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getAspectType(request: GetAspectTypeRequest) async throws
    -> GoogleCloudDataplexV1.AspectType
  {
    try await self.getAspectType(request: request, options: .init())
  }

  public func getAspectType(
    request: GetAspectTypeRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.AspectType {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getAspectType(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.AspectType {
    let request = GetAspectTypeRequest().with {
      $0.name = name
    }
    return try await self.getAspectType(request: request)
  }

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

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

  public func createEntryGroup(withPolling: CreateEntryGroupRequest) async throws
    -> any GoogleCloudGax.PollableOperation<EntryGroup>
  {
    try await self.createEntryGroup(withPolling: withPolling, options: .init())
  }

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

  public func createEntryGroup(
    parent: Swift.String,
    entryGroup: EntryGroup?,
    entryGroupId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<EntryGroup> {
    let request = CreateEntryGroupRequest().with {
      $0.parent = parent
      $0.entryGroup = entryGroup
      $0.entryGroupId = entryGroupId
    }
    return try await self.createEntryGroup(withPolling: request)
  }

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

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

  public func updateEntryGroup(withPolling: UpdateEntryGroupRequest) async throws
    -> any GoogleCloudGax.PollableOperation<EntryGroup>
  {
    try await self.updateEntryGroup(withPolling: withPolling, options: .init())
  }

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

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

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

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

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

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

  public func listEntryGroups(request: ListEntryGroupsRequest) async throws
    -> GoogleCloudDataplexV1.ListEntryGroupsResponse
  {
    try await self.listEntryGroups(request: request, options: .init())
  }

  public func listEntryGroups(
    request: ListEntryGroupsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListEntryGroupsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listEntryGroups(
    byItem: ListEntryGroupsRequest
  ) throws -> any AsyncSequence<EntryGroup, Swift.Error> {
    try self.listEntryGroups(byItem: byItem, options: .init())
  }

  public func listEntryGroups(
    byItem: ListEntryGroupsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<EntryGroup, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListEntryGroupsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getEntryGroup(request: GetEntryGroupRequest) async throws
    -> GoogleCloudDataplexV1.EntryGroup
  {
    try await self.getEntryGroup(request: request, options: .init())
  }

  public func getEntryGroup(
    request: GetEntryGroupRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryGroup {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getEntryGroup(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.EntryGroup {
    let request = GetEntryGroupRequest().with {
      $0.name = name
    }
    return try await self.getEntryGroup(request: request)
  }

  public func createEntry(request: CreateEntryRequest) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.createEntry(request: request, options: .init())
  }

  public func createEntry(
    request: CreateEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createEntry(
    parent: Swift.String,
    entry: Entry?,
    entryId: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.Entry {
    let request = CreateEntryRequest().with {
      $0.parent = parent
      $0.entry = entry
      $0.entryId = entryId
    }
    return try await self.createEntry(request: request)
  }

  public func updateEntry(request: UpdateEntryRequest) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.updateEntry(request: request, options: .init())
  }

  public func updateEntry(
    request: UpdateEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateEntry(
    entry: Entry?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> GoogleCloudDataplexV1.Entry {
    let request = UpdateEntryRequest().with {
      $0.entry = entry
      $0.updateMask = updateMask
    }
    return try await self.updateEntry(request: request)
  }

  public func deleteEntry(request: DeleteEntryRequest) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.deleteEntry(request: request, options: .init())
  }

  public func deleteEntry(
    request: DeleteEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteEntry(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.Entry {
    let request = DeleteEntryRequest().with {
      $0.name = name
    }
    return try await self.deleteEntry(request: request)
  }

  public func listEntries(request: ListEntriesRequest) async throws
    -> GoogleCloudDataplexV1.ListEntriesResponse
  {
    try await self.listEntries(request: request, options: .init())
  }

  public func listEntries(
    request: ListEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListEntriesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listEntries(
    byItem: ListEntriesRequest
  ) throws -> any AsyncSequence<Entry, Swift.Error> {
    try self.listEntries(byItem: byItem, options: .init())
  }

  public func listEntries(
    byItem: ListEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<Entry, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListEntriesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

  public func getEntry(request: GetEntryRequest) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.getEntry(request: request, options: .init())
  }

  public func getEntry(
    request: GetEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getEntry(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.Entry {
    let request = GetEntryRequest().with {
      $0.name = name
    }
    return try await self.getEntry(request: request)
  }

  public func lookupEntry(request: LookupEntryRequest) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.lookupEntry(request: request, options: .init())
  }

  public func lookupEntry(
    request: LookupEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func modifyEntry(request: ModifyEntryRequest) async throws -> GoogleCloudDataplexV1.Entry {
    try await self.modifyEntry(request: request, options: .init())
  }

  public func modifyEntry(
    request: ModifyEntryRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.Entry {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func searchEntries(request: SearchEntriesRequest) async throws
    -> GoogleCloudDataplexV1.SearchEntriesResponse
  {
    try await self.searchEntries(request: request, options: .init())
  }

  public func searchEntries(
    request: SearchEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.SearchEntriesResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func searchEntries(
    byItem: SearchEntriesRequest
  ) throws -> any AsyncSequence<SearchEntriesResult, Swift.Error> {
    try self.searchEntries(byItem: byItem, options: .init())
  }

  public func searchEntries(
    byItem: SearchEntriesRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<SearchEntriesResult, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.SearchEntriesResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

  public func createMetadataJob(withPolling: CreateMetadataJobRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MetadataJob>
  {
    try await self.createMetadataJob(withPolling: withPolling, options: .init())
  }

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

  public func createMetadataJob(
    parent: Swift.String,
    metadataJob: MetadataJob?,
    metadataJobId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<MetadataJob> {
    let request = CreateMetadataJobRequest().with {
      $0.parent = parent
      $0.metadataJob = metadataJob
      $0.metadataJobId = metadataJobId
    }
    return try await self.createMetadataJob(withPolling: request)
  }

  public func getMetadataJob(request: GetMetadataJobRequest) async throws
    -> GoogleCloudDataplexV1.MetadataJob
  {
    try await self.getMetadataJob(request: request, options: .init())
  }

  public func getMetadataJob(
    request: GetMetadataJobRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.MetadataJob {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getMetadataJob(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.MetadataJob {
    let request = GetMetadataJobRequest().with {
      $0.name = name
    }
    return try await self.getMetadataJob(request: request)
  }

  public func listMetadataJobs(request: ListMetadataJobsRequest) async throws
    -> GoogleCloudDataplexV1.ListMetadataJobsResponse
  {
    try await self.listMetadataJobs(request: request, options: .init())
  }

  public func listMetadataJobs(
    request: ListMetadataJobsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListMetadataJobsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listMetadataJobs(
    byItem: ListMetadataJobsRequest
  ) throws -> any AsyncSequence<MetadataJob, Swift.Error> {
    try self.listMetadataJobs(byItem: byItem, options: .init())
  }

  public func listMetadataJobs(
    byItem: ListMetadataJobsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MetadataJob, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListMetadataJobsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

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

  public func createEntryLink(request: CreateEntryLinkRequest) async throws
    -> GoogleCloudDataplexV1.EntryLink
  {
    try await self.createEntryLink(request: request, options: .init())
  }

  public func createEntryLink(
    request: CreateEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func createEntryLink(
    parent: Swift.String,
    entryLink: EntryLink?,
    entryLinkId: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    let request = CreateEntryLinkRequest().with {
      $0.parent = parent
      $0.entryLink = entryLink
      $0.entryLinkId = entryLinkId
    }
    return try await self.createEntryLink(request: request)
  }

  public func updateEntryLink(request: UpdateEntryLinkRequest) async throws
    -> GoogleCloudDataplexV1.EntryLink
  {
    try await self.updateEntryLink(request: request, options: .init())
  }

  public func updateEntryLink(
    request: UpdateEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func updateEntryLink(
    entryLink: EntryLink?,
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    let request = UpdateEntryLinkRequest().with {
      $0.entryLink = entryLink
    }
    return try await self.updateEntryLink(request: request)
  }

  public func deleteEntryLink(request: DeleteEntryLinkRequest) async throws
    -> GoogleCloudDataplexV1.EntryLink
  {
    try await self.deleteEntryLink(request: request, options: .init())
  }

  public func deleteEntryLink(
    request: DeleteEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func deleteEntryLink(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    let request = DeleteEntryLinkRequest().with {
      $0.name = name
    }
    return try await self.deleteEntryLink(request: request)
  }

  public func lookupEntryLinks(request: LookupEntryLinksRequest) async throws
    -> GoogleCloudDataplexV1.LookupEntryLinksResponse
  {
    try await self.lookupEntryLinks(request: request, options: .init())
  }

  public func lookupEntryLinks(
    request: LookupEntryLinksRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.LookupEntryLinksResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func lookupEntryLinks(
    byItem: LookupEntryLinksRequest
  ) throws -> any AsyncSequence<EntryLink, Swift.Error> {
    try self.lookupEntryLinks(byItem: byItem, options: .init())
  }

  public func lookupEntryLinks(
    byItem: LookupEntryLinksRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<EntryLink, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.LookupEntryLinksResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

  public func lookupContext(request: LookupContextRequest) async throws
    -> GoogleCloudDataplexV1.LookupContextResponse
  {
    try await self.lookupContext(request: request, options: .init())
  }

  public func lookupContext(
    request: LookupContextRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.LookupContextResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getEntryLink(request: GetEntryLinkRequest) async throws
    -> GoogleCloudDataplexV1.EntryLink
  {
    try await self.getEntryLink(request: request, options: .init())
  }

  public func getEntryLink(
    request: GetEntryLinkRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getEntryLink(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.EntryLink {
    let request = GetEntryLinkRequest().with {
      $0.name = name
    }
    return try await self.getEntryLink(request: request)
  }

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

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

  public func createMetadataFeed(withPolling: CreateMetadataFeedRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MetadataFeed>
  {
    try await self.createMetadataFeed(withPolling: withPolling, options: .init())
  }

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

  public func createMetadataFeed(
    parent: Swift.String,
    metadataFeed: MetadataFeed?,
    metadataFeedId: Swift.String,
  ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed> {
    let request = CreateMetadataFeedRequest().with {
      $0.parent = parent
      $0.metadataFeed = metadataFeed
      $0.metadataFeedId = metadataFeedId
    }
    return try await self.createMetadataFeed(withPolling: request)
  }

  public func getMetadataFeed(request: GetMetadataFeedRequest) async throws
    -> GoogleCloudDataplexV1.MetadataFeed
  {
    try await self.getMetadataFeed(request: request, options: .init())
  }

  public func getMetadataFeed(
    request: GetMetadataFeedRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.MetadataFeed {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func getMetadataFeed(
    name: Swift.String,
  ) async throws -> GoogleCloudDataplexV1.MetadataFeed {
    let request = GetMetadataFeedRequest().with {
      $0.name = name
    }
    return try await self.getMetadataFeed(request: request)
  }

  public func listMetadataFeeds(request: ListMetadataFeedsRequest) async throws
    -> GoogleCloudDataplexV1.ListMetadataFeedsResponse
  {
    try await self.listMetadataFeeds(request: request, options: .init())
  }

  public func listMetadataFeeds(
    request: ListMetadataFeedsRequest, options: GoogleCloudGax.RequestOptions
  ) async throws -> GoogleCloudDataplexV1.ListMetadataFeedsResponse {
    throw GoogleCloudGax.RequestError.unimplemented
  }

  public func listMetadataFeeds(
    byItem: ListMetadataFeedsRequest
  ) throws -> any AsyncSequence<MetadataFeed, Swift.Error> {
    try self.listMetadataFeeds(byItem: byItem, options: .init())
  }

  public func listMetadataFeeds(
    byItem: ListMetadataFeedsRequest, options: GoogleCloudGax.RequestOptions
  ) throws -> any AsyncSequence<MetadataFeed, Swift.Error> {
    let listRpc = {
      (token: Swift.String) async throws -> GoogleCloudDataplexV1.ListMetadataFeedsResponse in
      throw GoogleCloudGax.RequestError.unimplemented
    }
    return GoogleCloudGax.PaginatedResponseSequence(listRpc: listRpc)
  }

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

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

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

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

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

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

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

  public func updateMetadataFeed(withPolling: UpdateMetadataFeedRequest) async throws
    -> any GoogleCloudGax.PollableOperation<MetadataFeed>
  {
    try await self.updateMetadataFeed(withPolling: withPolling, options: .init())
  }

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

  public func updateMetadataFeed(
    metadataFeed: MetadataFeed?,
    updateMask: GoogleCloudWkt.FieldMask?,
  ) async throws -> any GoogleCloudGax.PollableOperation<MetadataFeed> {
    let request = UpdateMetadataFeedRequest().with {
      $0.metadataFeed = metadataFeed
      $0.updateMask = updateMask
    }
    return try await self.updateMetadataFeed(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)
  }
}
