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

import { domainsRegistrarBuyDomains } from "../funcs/domainsRegistrarBuyDomains.js";
import { domainsRegistrarBuySingleDomain } from "../funcs/domainsRegistrarBuySingleDomain.js";
import { domainsRegistrarGetBulkAvailability } from "../funcs/domainsRegistrarGetBulkAvailability.js";
import { domainsRegistrarGetContactInfoSchema } from "../funcs/domainsRegistrarGetContactInfoSchema.js";
import { domainsRegistrarGetDomainAuthCode } from "../funcs/domainsRegistrarGetDomainAuthCode.js";
import { domainsRegistrarGetDomainAvailability } from "../funcs/domainsRegistrarGetDomainAvailability.js";
import { domainsRegistrarGetDomainContactVerification } from "../funcs/domainsRegistrarGetDomainContactVerification.js";
import { domainsRegistrarGetDomainPrice } from "../funcs/domainsRegistrarGetDomainPrice.js";
import { domainsRegistrarGetDomainTransferIn } from "../funcs/domainsRegistrarGetDomainTransferIn.js";
import { domainsRegistrarGetOrder } from "../funcs/domainsRegistrarGetOrder.js";
import { domainsRegistrarGetSupportedTlds } from "../funcs/domainsRegistrarGetSupportedTlds.js";
import { domainsRegistrarGetTld } from "../funcs/domainsRegistrarGetTld.js";
import { domainsRegistrarGetTldPrice } from "../funcs/domainsRegistrarGetTldPrice.js";
import { domainsRegistrarRenewDomain } from "../funcs/domainsRegistrarRenewDomain.js";
import { domainsRegistrarTransferInDomain } from "../funcs/domainsRegistrarTransferInDomain.js";
import { domainsRegistrarUpdateDomainAutoRenew } from "../funcs/domainsRegistrarUpdateDomainAutoRenew.js";
import { domainsRegistrarUpdateDomainNameservers } from "../funcs/domainsRegistrarUpdateDomainNameservers.js";
import { ClientSDK, RequestOptions } from "../lib/sdks.js";
import {
  BuyDomainsRequest,
  BuyDomainsResponseBody,
} from "../models/buydomainsop.js";
import {
  BuySingleDomainRequest,
  BuySingleDomainResponseBody,
} from "../models/buysingledomainop.js";
import {
  GetBulkAvailabilityRequest,
  GetBulkAvailabilityResponseBody,
} from "../models/getbulkavailabilityop.js";
import {
  GetContactInfoSchemaRequest,
  GetContactInfoSchemaResponseBody,
} from "../models/getcontactinfoschemaop.js";
import {
  GetDomainAuthCodeRequest,
  GetDomainAuthCodeResponseBody,
} from "../models/getdomainauthcodeop.js";
import {
  GetDomainAvailabilityRequest,
  GetDomainAvailabilityResponseBody,
} from "../models/getdomainavailabilityop.js";
import {
  GetDomainContactVerificationRequest,
  GetDomainContactVerificationResponseBody,
} from "../models/getdomaincontactverificationop.js";
import {
  GetDomainPriceRequest,
  GetDomainPriceResponseBody,
} from "../models/getdomainpriceop.js";
import {
  GetDomainTransferInRequest,
  GetDomainTransferInResponseBody,
} from "../models/getdomaintransferinop.js";
import { GetOrderRequest, GetOrderResponseBody } from "../models/getorderop.js";
import { GetSupportedTldsRequest } from "../models/getsupportedtldsop.js";
import { GetTldRequest, GetTldResponseBody } from "../models/gettldop.js";
import {
  GetTldPriceRequest,
  GetTldPriceResponseBody,
} from "../models/gettldpriceop.js";
import {
  RenewDomainRequest,
  RenewDomainResponseBody,
} from "../models/renewdomainop.js";
import {
  TransferInDomainRequest,
  TransferInDomainResponseBody,
} from "../models/transferindomainop.js";
import { UpdateDomainAutoRenewRequest } from "../models/updatedomainautorenewop.js";
import { UpdateDomainNameserversRequest } from "../models/updatedomainnameserversop.js";
import { unwrapAsync } from "../types/fp.js";

export class DomainsRegistrar extends ClientSDK {
  /**
   * Get supported TLDs
   *
   * @remarks
   * Get a list of TLDs supported by Vercel
   */
  async getSupportedTlds(
    request: GetSupportedTldsRequest,
    options?: RequestOptions,
  ): Promise<Array<string>> {
    return unwrapAsync(domainsRegistrarGetSupportedTlds(
      this,
      request,
      options,
    ));
  }

  /**
   * Get TLD
   *
   * @remarks
   * Get the metadata for a specific TLD.
   */
  async getTld(
    request: GetTldRequest,
    options?: RequestOptions,
  ): Promise<GetTldResponseBody> {
    return unwrapAsync(domainsRegistrarGetTld(
      this,
      request,
      options,
    ));
  }

  /**
   * Get TLD price data
   *
   * @remarks
   * Get price data for a specific TLD. This only reflects base prices for the given TLD. Premium domains may have different prices. Use the [Get price data for a domain](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/get-price-data-for-a-domain) endpoint to get the price data for a specific domain.
   */
  async getTldPrice(
    request: GetTldPriceRequest,
    options?: RequestOptions,
  ): Promise<GetTldPriceResponseBody> {
    return unwrapAsync(domainsRegistrarGetTldPrice(
      this,
      request,
      options,
    ));
  }

  /**
   * Get availability for a domain
   *
   * @remarks
   * Get availability for a specific domain. If the domain is available, it can be purchased using the [Buy a domain](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/buy-a-domain) endpoint or the [Buy multiple domains](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/buy-multiple-domains) endpoint.
   */
  async getDomainAvailability(
    request: GetDomainAvailabilityRequest,
    options?: RequestOptions,
  ): Promise<GetDomainAvailabilityResponseBody> {
    return unwrapAsync(domainsRegistrarGetDomainAvailability(
      this,
      request,
      options,
    ));
  }

  /**
   * Get price data for a domain
   *
   * @remarks
   * Get price data for a specific domain
   */
  async getDomainPrice(
    request: GetDomainPriceRequest,
    options?: RequestOptions,
  ): Promise<GetDomainPriceResponseBody> {
    return unwrapAsync(domainsRegistrarGetDomainPrice(
      this,
      request,
      options,
    ));
  }

  /**
   * Get availability for multiple domains
   *
   * @remarks
   * Get availability for multiple domains. If the domains are available, they can be purchased using the [Buy a domain](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/buy-a-domain) endpoint or the [Buy multiple domains](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/buy-multiple-domains) endpoint.
   */
  async getBulkAvailability(
    request: GetBulkAvailabilityRequest,
    options?: RequestOptions,
  ): Promise<GetBulkAvailabilityResponseBody> {
    return unwrapAsync(domainsRegistrarGetBulkAvailability(
      this,
      request,
      options,
    ));
  }

  /**
   * Get the auth code for a domain
   *
   * @remarks
   * Get the auth code for a domain. This is required to transfer a domain from Vercel to another registrar.
   */
  async getDomainAuthCode(
    request: GetDomainAuthCodeRequest,
    options?: RequestOptions,
  ): Promise<GetDomainAuthCodeResponseBody> {
    return unwrapAsync(domainsRegistrarGetDomainAuthCode(
      this,
      request,
      options,
    ));
  }

  /**
   * Buy a domain
   *
   * @remarks
   * Buy a domain
   */
  async buySingleDomain(
    request: BuySingleDomainRequest,
    options?: RequestOptions,
  ): Promise<BuySingleDomainResponseBody> {
    return unwrapAsync(domainsRegistrarBuySingleDomain(
      this,
      request,
      options,
    ));
  }

  /**
   * Buy multiple domains
   *
   * @remarks
   * Buy multiple domains at once
   */
  async buyDomains(
    request: BuyDomainsRequest,
    options?: RequestOptions,
  ): Promise<BuyDomainsResponseBody> {
    return unwrapAsync(domainsRegistrarBuyDomains(
      this,
      request,
      options,
    ));
  }

  /**
   * Transfer-in a domain
   *
   * @remarks
   * Transfer a domain in from another registrar
   */
  async transferInDomain(
    request: TransferInDomainRequest,
    options?: RequestOptions,
  ): Promise<TransferInDomainResponseBody> {
    return unwrapAsync(domainsRegistrarTransferInDomain(
      this,
      request,
      options,
    ));
  }

  /**
   * Get a domain's transfer status
   *
   * @remarks
   * Get the transfer status for a domain
   */
  async getDomainTransferIn(
    request: GetDomainTransferInRequest,
    options?: RequestOptions,
  ): Promise<GetDomainTransferInResponseBody> {
    return unwrapAsync(domainsRegistrarGetDomainTransferIn(
      this,
      request,
      options,
    ));
  }

  /**
   * Renew a domain
   *
   * @remarks
   * Renew a domain
   */
  async renewDomain(
    request: RenewDomainRequest,
    options?: RequestOptions,
  ): Promise<RenewDomainResponseBody> {
    return unwrapAsync(domainsRegistrarRenewDomain(
      this,
      request,
      options,
    ));
  }

  /**
   * Update auto-renew for a domain
   *
   * @remarks
   * Update the auto-renew setting for a domain
   */
  async updateDomainAutoRenew(
    request: UpdateDomainAutoRenewRequest,
    options?: RequestOptions,
  ): Promise<void> {
    return unwrapAsync(domainsRegistrarUpdateDomainAutoRenew(
      this,
      request,
      options,
    ));
  }

  /**
   * Update nameservers for a domain
   *
   * @remarks
   * Update the nameservers for a domain. Pass an empty array to use Vercel's default nameservers.
   */
  async updateDomainNameservers(
    request: UpdateDomainNameserversRequest,
    options?: RequestOptions,
  ): Promise<void> {
    return unwrapAsync(domainsRegistrarUpdateDomainNameservers(
      this,
      request,
      options,
    ));
  }

  /**
   * Get contact verification status for a domain
   *
   * @remarks
   * Get the registrant contact verification status for a domain. Use this after purchasing a domain to determine whether the contact has been verified. Note that a bought_too_recently error will be returned if the domain was bought less than 30 minutes before the request.
   */
  async getDomainContactVerification(
    request: GetDomainContactVerificationRequest,
    options?: RequestOptions,
  ): Promise<GetDomainContactVerificationResponseBody> {
    return unwrapAsync(domainsRegistrarGetDomainContactVerification(
      this,
      request,
      options,
    ));
  }

  /**
   * Get contact info schema
   *
   * @remarks
   * Some TLDs require additional contact information. Use this endpoint to get the schema for the tld-specific contact information for a domain.
   */
  async getContactInfoSchema(
    request: GetContactInfoSchemaRequest,
    options?: RequestOptions,
  ): Promise<GetContactInfoSchemaResponseBody> {
    return unwrapAsync(domainsRegistrarGetContactInfoSchema(
      this,
      request,
      options,
    ));
  }

  /**
   * Get a domain order
   *
   * @remarks
   * Get information about a domain order by its ID
   */
  async getOrder(
    request: GetOrderRequest,
    options?: RequestOptions,
  ): Promise<GetOrderResponseBody> {
    return unwrapAsync(domainsRegistrarGetOrder(
      this,
      request,
      options,
    ));
  }
}