/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 * @generated-id: 3fd9eddb05f9
 */

import { managersCancelSetup } from "../funcs/managersCancelSetup.js";
import { managersCreate } from "../funcs/managersCreate.js";
import { managersDelete } from "../funcs/managersDelete.js";
import { managersGenerateManagerBindingToken } from "../funcs/managersGenerateManagerBindingToken.js";
import { managersGenerateManagerToken } from "../funcs/managersGenerateManagerToken.js";
import { managersGet } from "../funcs/managersGet.js";
import { managersGetDeployment } from "../funcs/managersGetDeployment.js";
import { managersGetDomainBinding } from "../funcs/managersGetDomainBinding.js";
import { managersGetManagementConfig } from "../funcs/managersGetManagementConfig.js";
import { managersList } from "../funcs/managersList.js";
import { managersListEvents } from "../funcs/managersListEvents.js";
import { managersProvision } from "../funcs/managersProvision.js";
import { managersReportHeartbeat } from "../funcs/managersReportHeartbeat.js";
import { managersResolveGcpOAuthProvider } from "../funcs/managersResolveGcpOAuthProvider.js";
import { managersRetry } from "../funcs/managersRetry.js";
import { managersRetrySetup } from "../funcs/managersRetrySetup.js";
import { managersUpdate } from "../funcs/managersUpdate.js";
import { managersUpdateDomainBinding } from "../funcs/managersUpdateDomainBinding.js";
import { ClientSDK, RequestOptions } from "../lib/sdks.js";
import * as models from "../models/index.js";
import * as operations from "../models/operations/index.js";
import { unwrapAsync } from "../types/fp.js";

export class Managers extends ClientSDK {
  /**
   * Create a new manager.
   */
  async create(
    request?: models.NewManagerRequest | undefined,
    options?: RequestOptions,
  ): Promise<models.CreateManagerResponse> {
    return unwrapAsync(managersCreate(
      this,
      request,
      options,
    ));
  }

  /**
   * Retrieve all managers.
   */
  async list(
    request?: operations.ListManagersRequest | undefined,
    options?: RequestOptions,
  ): Promise<Array<models.Manager>> {
    return unwrapAsync(managersList(
      this,
      request,
      options,
    ));
  }

  /**
   * Revoke previous private-manager setup tokens and issue a fresh setup token/config.
   */
  async retrySetup(
    request: operations.RetryManagerSetupRequest,
    options?: RequestOptions,
  ): Promise<models.CreateManagerResponse> {
    return unwrapAsync(managersRetrySetup(
      this,
      request,
      options,
    ));
  }

  /**
   * Retry private-manager setup. Returns a fresh setup action before the internal deployment exists, or requests retry for the internal deployment after it exists.
   */
  async retry(
    request: operations.RetryManagerRequest,
    options?: RequestOptions,
  ): Promise<models.ManagerRetryResponse> {
    return unwrapAsync(managersRetry(
      this,
      request,
      options,
    ));
  }

  /**
   * Cancel pending private-manager setup, revoke setup/runtime tokens, and remove the undeployed manager record.
   */
  async cancelSetup(
    request: operations.CancelManagerSetupRequest,
    options?: RequestOptions,
  ): Promise<operations.CancelManagerSetupResponse> {
    return unwrapAsync(managersCancelSetup(
      this,
      request,
      options,
    ));
  }

  /**
   * Retrieve a manager by ID.
   */
  async get(
    request: operations.GetManagerRequest,
    options?: RequestOptions,
  ): Promise<models.Manager> {
    return unwrapAsync(managersGet(
      this,
      request,
      options,
    ));
  }

  /**
   * Delete a manager by ID.
   */
  async delete(
    request: operations.DeleteManagerRequest,
    options?: RequestOptions,
  ): Promise<operations.DeleteManagerResponse> {
    return unwrapAsync(managersDelete(
      this,
      request,
      options,
    ));
  }

  /**
   * Get the custom domain binding for a private manager.
   */
  async getDomainBinding(
    request: operations.GetManagerDomainBindingRequest,
    options?: RequestOptions,
  ): Promise<models.ManagerDomainBindingResponse> {
    return unwrapAsync(managersGetDomainBinding(
      this,
      request,
      options,
    ));
  }

  /**
   * Create, update, or remove the custom domain binding for a private manager.
   */
  async updateDomainBinding(
    request: operations.UpdateManagerDomainBindingRequest,
    options?: RequestOptions,
  ): Promise<models.ManagerDomainBindingResponse> {
    return unwrapAsync(managersUpdateDomainBinding(
      this,
      request,
      options,
    ));
  }

  /**
   * Get the management configuration for a manager.
   */
  async getManagementConfig(
    request: operations.GetManagerManagementConfigRequest,
    options?: RequestOptions,
  ): Promise<operations.GetManagerManagementConfigResponse> {
    return unwrapAsync(managersGetManagementConfig(
      this,
      request,
      options,
    ));
  }

  /**
   * Enqueue provisioning for a manager by ID.
   */
  async provision(
    request: operations.ProvisionManagerRequest,
    options?: RequestOptions,
  ): Promise<operations.ProvisionManagerResponse> {
    return unwrapAsync(managersProvision(
      this,
      request,
      options,
    ));
  }

  /**
   * Update a manager to a specific release ID or active release.
   */
  async update(
    request: operations.UpdateManagerRequest,
    options?: RequestOptions,
  ): Promise<operations.UpdateManagerResponse> {
    return unwrapAsync(managersUpdate(
      this,
      request,
      options,
    ));
  }

  /**
   * Retrieve all events of a manager.
   */
  async listEvents(
    request: operations.ListManagerEventsRequest,
    options?: RequestOptions,
  ): Promise<operations.ListManagerEventsResponse> {
    return unwrapAsync(managersListEvents(
      this,
      request,
      options,
    ));
  }

  /**
   * Generate a short-lived JWT for direct browser → manager communication. Used for fetching command payloads and querying logs without routing sensitive data through the platform API.
   */
  async generateManagerToken(
    request: operations.GenerateManagerTokenRequest,
    options?: RequestOptions,
  ): Promise<models.GenerateManagerTokenResponse> {
    return unwrapAsync(managersGenerateManagerToken(
      this,
      request,
      options,
    ));
  }

  /**
   * Generate a short-lived deployment-scoped token for resolving opted-in remote bindings through the currently assigned manager.
   */
  async generateManagerBindingToken(
    request: operations.GenerateManagerBindingTokenRequest,
    options?: RequestOptions,
  ): Promise<models.GenerateManagerBindingTokenResponse> {
    return unwrapAsync(managersGenerateManagerBindingToken(
      this,
      request,
      options,
    ));
  }

  /**
   * Resolve decrypted project-level Google Cloud OAuth provider settings for a manager-side deployment bootstrap.
   */
  async resolveGcpOAuthProvider(
    request: operations.ResolveManagerGcpOAuthProviderRequest,
    options?: RequestOptions,
  ): Promise<models.ResolveManagerGcpOAuthProviderResponse> {
    return unwrapAsync(managersResolveGcpOAuthProvider(
      this,
      request,
      options,
    ));
  }

  /**
   * Report Manager health status and metrics.
   */
  async reportHeartbeat(
    request: operations.ReportManagerHeartbeatRequest,
    options?: RequestOptions,
  ): Promise<models.ManagerHeartbeatResponse> {
    return unwrapAsync(managersReportHeartbeat(
      this,
      request,
      options,
    ));
  }

  /**
   * Get deployment details for a private manager (internal deployment platform, status, resources).
   */
  async getDeployment(
    request: operations.GetManagerDeploymentRequest,
    options?: RequestOptions,
  ): Promise<models.ManagerDeployment> {
    return unwrapAsync(managersGetDeployment(
      this,
      request,
      options,
    ));
  }
}