/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import { kmsActivateKmsSigningKey } from "../funcs/kmsActivateKmsSigningKey.js";
import { kmsCreateKmsIssuer } from "../funcs/kmsCreateKmsIssuer.js";
import { kmsCreateKmsIssuerPolicy } from "../funcs/kmsCreateKmsIssuerPolicy.js";
import { kmsCreateKmsSigningKey } from "../funcs/kmsCreateKmsSigningKey.js";
import { kmsDeleteKmsIssuer } from "../funcs/kmsDeleteKmsIssuer.js";
import { kmsDeleteKmsIssuerPolicy } from "../funcs/kmsDeleteKmsIssuerPolicy.js";
import { kmsGetKmsIssuer } from "../funcs/kmsGetKmsIssuer.js";
import { kmsListKmsIssuers } from "../funcs/kmsListKmsIssuers.js";
import { kmsRevokeKmsSigningKey } from "../funcs/kmsRevokeKmsSigningKey.js";
import { kmsSignKmsMessage } from "../funcs/kmsSignKmsMessage.js";
import { kmsSignKmsToken } from "../funcs/kmsSignKmsToken.js";
import { kmsUpdateKmsIssuer } from "../funcs/kmsUpdateKmsIssuer.js";
import { kmsUpdateKmsIssuerPolicy } from "../funcs/kmsUpdateKmsIssuerPolicy.js";
import { ClientSDK, RequestOptions } from "../lib/sdks.js";
import {
  ActivateKmsSigningKeyRequest,
  ActivateKmsSigningKeyResponseBody,
} from "../models/activatekmssigningkeyop.js";
import {
  CreateKmsIssuerRequest,
  CreateKmsIssuerResponseBody,
} from "../models/createkmsissuerop.js";
import {
  CreateKmsIssuerPolicyRequest,
  CreateKmsIssuerPolicyResponseBody,
} from "../models/createkmsissuerpolicyop.js";
import {
  CreateKmsSigningKeyRequest,
  CreateKmsSigningKeyResponseBody,
} from "../models/createkmssigningkeyop.js";
import { DeleteKmsIssuerRequest } from "../models/deletekmsissuerop.js";
import { DeleteKmsIssuerPolicyRequest } from "../models/deletekmsissuerpolicyop.js";
import {
  GetKmsIssuerRequest,
  GetKmsIssuerResponseBody,
} from "../models/getkmsissuerop.js";
import {
  ListKmsIssuersRequest,
  ListKmsIssuersResponseBody,
} from "../models/listkmsissuersop.js";
import {
  RevokeKmsSigningKeyRequest,
  RevokeKmsSigningKeyResponseBody,
} from "../models/revokekmssigningkeyop.js";
import {
  SignKmsMessageRequest,
  SignKmsMessageResponseBody,
} from "../models/signkmsmessageop.js";
import {
  SignKmsTokenRequest,
  SignKmsTokenResponseBody,
} from "../models/signkmstokenop.js";
import {
  UpdateKmsIssuerRequest,
  UpdateKmsIssuerResponseBody,
} from "../models/updatekmsissuerop.js";
import {
  UpdateKmsIssuerPolicyRequest,
  UpdateKmsIssuerPolicyResponseBody,
} from "../models/updatekmsissuerpolicyop.js";
import { unwrapAsync } from "../types/fp.js";

export class Kms extends ClientSDK {
  /**
   * List issuers
   *
   * @remarks
   * Retrieve the list of KMS issuers that belong to the authenticated team. The results are paginated.
   */
  async listKmsIssuers(
    request: ListKmsIssuersRequest,
    options?: RequestOptions,
  ): Promise<ListKmsIssuersResponseBody> {
    return unwrapAsync(kmsListKmsIssuers(
      this,
      request,
      options,
    ));
  }

  /**
   * Create an issuer
   *
   * @remarks
   * Create a new KMS issuer for the authenticated team. An issuer owns the asymmetric signing keys that are used to sign tokens and messages.
   */
  async createKmsIssuer(
    request: CreateKmsIssuerRequest,
    options?: RequestOptions,
  ): Promise<CreateKmsIssuerResponseBody> {
    return unwrapAsync(kmsCreateKmsIssuer(
      this,
      request,
      options,
    ));
  }

  /**
   * Sign a message
   *
   * @remarks
   * Sign a raw message with a KMS issuer's active signing key. Authenticate the request with a Vercel OIDC token in the `Authorization: Bearer` header; the issuer's policies decide which workloads are allowed to sign.
   */
  async signKmsMessage(
    request: SignKmsMessageRequest,
    options?: RequestOptions,
  ): Promise<SignKmsMessageResponseBody> {
    return unwrapAsync(kmsSignKmsMessage(
      this,
      request,
      options,
    ));
  }

  /**
   * Sign a token
   *
   * @remarks
   * Sign a JWT with a KMS issuer's active signing key. Authenticate the request with a Vercel OIDC token in the `Authorization: Bearer` header; the issuer's policies decide which workloads are allowed to sign.
   */
  async signKmsToken(
    request: SignKmsTokenRequest,
    options?: RequestOptions,
  ): Promise<SignKmsTokenResponseBody> {
    return unwrapAsync(kmsSignKmsToken(
      this,
      request,
      options,
    ));
  }

  /**
   * Create a signing key
   *
   * @remarks
   * Create a new signing key for a KMS issuer. Depending on the activation mode, the key is activated automatically once its public key has propagated, or manually via the activate endpoint.
   */
  async createKmsSigningKey(
    request: CreateKmsSigningKeyRequest,
    options?: RequestOptions,
  ): Promise<CreateKmsSigningKeyResponseBody> {
    return unwrapAsync(kmsCreateKmsSigningKey(
      this,
      request,
      options,
    ));
  }

  /**
   * Activate a signing key
   *
   * @remarks
   * Activate a pending signing key so the issuer starts signing with it.
   */
  async activateKmsSigningKey(
    request: ActivateKmsSigningKeyRequest,
    options?: RequestOptions,
  ): Promise<ActivateKmsSigningKeyResponseBody> {
    return unwrapAsync(kmsActivateKmsSigningKey(
      this,
      request,
      options,
    ));
  }

  /**
   * Revoke a signing key
   *
   * @remarks
   * Immediately revoke a signing key that is already scheduled for revocation.
   */
  async revokeKmsSigningKey(
    request: RevokeKmsSigningKeyRequest,
    options?: RequestOptions,
  ): Promise<RevokeKmsSigningKeyResponseBody> {
    return unwrapAsync(kmsRevokeKmsSigningKey(
      this,
      request,
      options,
    ));
  }

  /**
   * Get an issuer
   *
   * @remarks
   * Retrieve a single KMS issuer by its ID. Accepts either a team bearer token (existing path) or an OIDC token authorized by one of the issuer's policies (e.g. a connex-grant token). The OIDC path returns the issuer without policies, since a policy token only proves signing access, not management access.
   */
  async getKmsIssuer(
    request: GetKmsIssuerRequest,
    options?: RequestOptions,
  ): Promise<GetKmsIssuerResponseBody> {
    return unwrapAsync(kmsGetKmsIssuer(
      this,
      request,
      options,
    ));
  }

  /**
   * Update an issuer
   *
   * @remarks
   * Update a KMS issuer's name or claims schema.
   */
  async updateKmsIssuer(
    request: UpdateKmsIssuerRequest,
    options?: RequestOptions,
  ): Promise<UpdateKmsIssuerResponseBody> {
    return unwrapAsync(kmsUpdateKmsIssuer(
      this,
      request,
      options,
    ));
  }

  /**
   * Delete an issuer
   *
   * @remarks
   * Delete a KMS issuer and its signing keys.
   */
  async deleteKmsIssuer(
    request: DeleteKmsIssuerRequest,
    options?: RequestOptions,
  ): Promise<void> {
    return unwrapAsync(kmsDeleteKmsIssuer(
      this,
      request,
      options,
    ));
  }

  /**
   * Create an issuer policy
   *
   * @remarks
   * Attach a policy to a KMS issuer that grants a project's deployments permission to sign with it.
   */
  async createKmsIssuerPolicy(
    request: CreateKmsIssuerPolicyRequest,
    options?: RequestOptions,
  ): Promise<CreateKmsIssuerPolicyResponseBody> {
    return unwrapAsync(kmsCreateKmsIssuerPolicy(
      this,
      request,
      options,
    ));
  }

  /**
   * Update an issuer policy
   *
   * @remarks
   * Update an existing KMS issuer policy's environments or token claims.
   */
  async updateKmsIssuerPolicy(
    request: UpdateKmsIssuerPolicyRequest,
    options?: RequestOptions,
  ): Promise<UpdateKmsIssuerPolicyResponseBody> {
    return unwrapAsync(kmsUpdateKmsIssuerPolicy(
      this,
      request,
      options,
    ));
  }

  /**
   * Delete an issuer policy
   *
   * @remarks
   * Remove a policy from a KMS issuer.
   */
  async deleteKmsIssuerPolicy(
    request: DeleteKmsIssuerPolicyRequest,
    options?: RequestOptions,
  ): Promise<void> {
    return unwrapAsync(kmsDeleteKmsIssuerPolicy(
      this,
      request,
      options,
    ));
  }
}