@vercel/sdk/src/models/buydomainsop.ts

<p align="center"> <a href="https://vercel.com"> <img src="https://assets.vercel.com/image/upload/v1588805858/repositories/vercel/logo.png" height="96"> <h3 align="center">Vercel</h3> </a> <p align="center">Develop. Preview. Ship.</p> </p>

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

import * as z from "zod/v3";
import { remap as remap$ } from "../lib/primitives.js";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import * as types from "../types/primitives.js";
import { smartUnion } from "../types/smartUnion.js";
import {
  AdditionalContactInfoRequired,
  AdditionalContactInfoRequired$inboundSchema,
} from "./additionalcontactinforequired.js";
import {
  DomainNotAvailable,
  DomainNotAvailable$inboundSchema,
} from "./domainnotavailable.js";
import {
  DomainTooShort,
  DomainTooShort$inboundSchema,
} from "./domaintooshort.js";
import {
  DuplicateDomains,
  DuplicateDomains$inboundSchema,
} from "./duplicatedomains.js";
import {
  ExpectedPriceMismatch,
  ExpectedPriceMismatch$inboundSchema,
} from "./expectedpricemismatch.js";
import { Forbidden, Forbidden$inboundSchema } from "./forbidden.js";
import {
  HttpApiDecodeError,
  HttpApiDecodeError$inboundSchema,
} from "./httpapidecodeerror.js";
import {
  InvalidAdditionalContactInfo,
  InvalidAdditionalContactInfo$inboundSchema,
} from "./invalidadditionalcontactinfo.js";
import {
  LanguageCodeRequired,
  LanguageCodeRequired$inboundSchema,
} from "./languagecoderequired.js";
import {
  NotAuthorizedForScope,
  NotAuthorizedForScope$inboundSchema,
} from "./notauthorizedforscope.js";
import {
  OrderTooExpensive,
  OrderTooExpensive$inboundSchema,
} from "./ordertooexpensive.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
import {
  TldNotSupported,
  TldNotSupported$inboundSchema,
} from "./tldnotsupported.js";
import {
  TooManyDomains,
  TooManyDomains$inboundSchema,
} from "./toomanydomains.js";

export type Domains = {
  /**
   * A valid domain name
   */
  domainName: string;
  /**
   * Whether the domain should be auto-renewed before it expires. This can be configured later through the Vercel Dashboard or the [Update auto-renew for a domain](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/update-auto-renew-for-a-domain) endpoint.
   */
  autoRenew: boolean;
  /**
   * The number of years to purchase the domain for.
   */
  years: number;
  expectedPrice: number;
  /**
   * The language code for the domain. For punycode domains, this must be provided. The list of supported language codes for a TLD can be retrieved from the [Get TLD](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/get-tld) endpoint.
   */
  languageCode?: string | undefined;
};

export type BuyDomainsAdditional = {};

/**
 * The contact information for the domain. Some TLDs require additional contact information. Use the [Get contact info schema](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/get-contact-info-schema) endpoint to retrieve the required fields.
 */
export type BuyDomainsContactInformation = {
  /**
   * a non empty string
   */
  firstName: string;
  /**
   * a non empty string
   */
  lastName: string;
  /**
   * A valid RFC 5322 email address
   */
  email: string;
  /**
   * A valid E.164 phone number
   */
  phone: string;
  /**
   * a non empty string
   */
  address1: string;
  /**
   * a non empty string
   */
  address2?: string | undefined;
  /**
   * a non empty string
   */
  city: string;
  /**
   * a non empty string
   */
  state: string;
  /**
   * a non empty string
   */
  zip: string;
  /**
   * A valid ISO 3166-1 alpha-2 country code
   */
  country: string;
  /**
   * a non empty string
   */
  companyName?: string | undefined;
  /**
   * A valid E.164 phone number
   */
  fax?: string | undefined;
  additional?: BuyDomainsAdditional | undefined;
};

export type BuyDomainsRequestBody = {
  domains: Array<Domains>;
  /**
   * The contact information for the domain. Some TLDs require additional contact information. Use the [Get contact info schema](https://vercel.com/docs/rest-api/reference/endpoints/domains-registrar/get-contact-info-schema) endpoint to retrieve the required fields.
   */
  contactInformation: BuyDomainsContactInformation;
};

export type BuyDomainsRequest = {
  teamId?: string | undefined;
  requestBody: BuyDomainsRequestBody;
};

/**
 * NotAuthorizedForScope
 */
export type BuyDomainsDomainsRegistrarResponseResponseBody =
  | (NotAuthorizedForScope & { code: "not_authorized_for_scope" })
  | Forbidden;

/**
 * There was something wrong with the request
 */
export type BuyDomainsDomainsRegistrarResponseBody =
  | DomainTooShort
  | OrderTooExpensive
  | TooManyDomains
  | InvalidAdditionalContactInfo
  | AdditionalContactInfoRequired
  | DuplicateDomains
  | ExpectedPriceMismatch
  | DomainNotAvailable
  | LanguageCodeRequired
  | TldNotSupported
  | HttpApiDecodeError;

export const BuyDomainsMethod = {
  Get: "GET",
  Post: "POST",
  Put: "PUT",
  Delete: "DELETE",
  Patch: "PATCH",
} as const;
export type BuyDomainsMethod = ClosedEnum<typeof BuyDomainsMethod>;

export type BuyDomainsLinks = {
  href: string;
  method: BuyDomainsMethod;
};

/**
 * Success
 */
export type BuyDomainsResponseBody = {
  /**
   * A valid order ID
   */
  orderId: string;
  links: { [k: string]: BuyDomainsLinks };
};

/** @internal */
export type Domains$Outbound = {
  domainName: string;
  autoRenew: boolean;
  years: number;
  expectedPrice: number;
  languageCode?: string | undefined;
};

/** @internal */
export const Domains$outboundSchema: z.ZodType<
  Domains$Outbound,
  z.ZodTypeDef,
  Domains
> = z.object({
  domainName: z.string(),
  autoRenew: z.boolean(),
  years: z.number(),
  expectedPrice: z.number(),
  languageCode: z.string().optional(),
});

export function domainsToJSON(domains: Domains): string {
  return JSON.stringify(Domains$outboundSchema.parse(domains));
}

/** @internal */
export type BuyDomainsAdditional$Outbound = {};

/** @internal */
export const BuyDomainsAdditional$outboundSchema: z.ZodType<
  BuyDomainsAdditional$Outbound,
  z.ZodTypeDef,
  BuyDomainsAdditional
> = z.object({});

export function buyDomainsAdditionalToJSON(
  buyDomainsAdditional: BuyDomainsAdditional,
): string {
  return JSON.stringify(
    BuyDomainsAdditional$outboundSchema.parse(buyDomainsAdditional),
  );
}

/** @internal */
export type BuyDomainsContactInformation$Outbound = {
  firstName: string;
  lastName: string;
  email: string;
  phone: string;
  address1: string;
  address2?: string | undefined;
  city: string;
  state: string;
  zip: string;
  country: string;
  companyName?: string | undefined;
  fax?: string | undefined;
  additional?: BuyDomainsAdditional$Outbound | undefined;
};

/** @internal */
export const BuyDomainsContactInformation$outboundSchema: z.ZodType<
  BuyDomainsContactInformation$Outbound,
  z.ZodTypeDef,
  BuyDomainsContactInformation
> = z.object({
  firstName: z.string(),
  lastName: z.string(),
  email: z.string(),
  phone: z.string(),
  address1: z.string(),
  address2: z.string().optional(),
  city: z.string(),
  state: z.string(),
  zip: z.string(),
  country: z.string(),
  companyName: z.string().optional(),
  fax: z.string().optional(),
  additional: z.lazy(() => BuyDomainsAdditional$outboundSchema).optional(),
});

export function buyDomainsContactInformationToJSON(
  buyDomainsContactInformation: BuyDomainsContactInformation,
): string {
  return JSON.stringify(
    BuyDomainsContactInformation$outboundSchema.parse(
      buyDomainsContactInformation,
    ),
  );
}

/** @internal */
export type BuyDomainsRequestBody$Outbound = {
  domains: Array<Domains$Outbound>;
  contactInformation: BuyDomainsContactInformation$Outbound;
};

/** @internal */
export const BuyDomainsRequestBody$outboundSchema: z.ZodType<
  BuyDomainsRequestBody$Outbound,
  z.ZodTypeDef,
  BuyDomainsRequestBody
> = z.object({
  domains: z.array(z.lazy(() => Domains$outboundSchema)),
  contactInformation: z.lazy(() => BuyDomainsContactInformation$outboundSchema),
});

export function buyDomainsRequestBodyToJSON(
  buyDomainsRequestBody: BuyDomainsRequestBody,
): string {
  return JSON.stringify(
    BuyDomainsRequestBody$outboundSchema.parse(buyDomainsRequestBody),
  );
}

/** @internal */
export type BuyDomainsRequest$Outbound = {
  teamId?: string | undefined;
  RequestBody: BuyDomainsRequestBody$Outbound;
};

/** @internal */
export const BuyDomainsRequest$outboundSchema: z.ZodType<
  BuyDomainsRequest$Outbound,
  z.ZodTypeDef,
  BuyDomainsRequest
> = z.object({
  teamId: z.string().optional(),
  requestBody: z.lazy(() => BuyDomainsRequestBody$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function buyDomainsRequestToJSON(
  buyDomainsRequest: BuyDomainsRequest,
): string {
  return JSON.stringify(
    BuyDomainsRequest$outboundSchema.parse(buyDomainsRequest),
  );
}

/** @internal */
export const BuyDomainsDomainsRegistrarResponseResponseBody$inboundSchema:
  z.ZodType<
    BuyDomainsDomainsRegistrarResponseResponseBody,
    z.ZodTypeDef,
    unknown
  > = z.union([
    NotAuthorizedForScope$inboundSchema.and(
      z.object({ code: z.literal("not_authorized_for_scope") }),
    ),
    Forbidden$inboundSchema,
  ]);

export function buyDomainsDomainsRegistrarResponseResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<
  BuyDomainsDomainsRegistrarResponseResponseBody,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      BuyDomainsDomainsRegistrarResponseResponseBody$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'BuyDomainsDomainsRegistrarResponseResponseBody' from JSON`,
  );
}

/** @internal */
export const BuyDomainsDomainsRegistrarResponseBody$inboundSchema: z.ZodType<
  BuyDomainsDomainsRegistrarResponseBody,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  DomainTooShort$inboundSchema,
  OrderTooExpensive$inboundSchema,
  TooManyDomains$inboundSchema,
  InvalidAdditionalContactInfo$inboundSchema,
  AdditionalContactInfoRequired$inboundSchema,
  DuplicateDomains$inboundSchema,
  ExpectedPriceMismatch$inboundSchema,
  DomainNotAvailable$inboundSchema,
  LanguageCodeRequired$inboundSchema,
  TldNotSupported$inboundSchema,
  HttpApiDecodeError$inboundSchema,
]);

export function buyDomainsDomainsRegistrarResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<BuyDomainsDomainsRegistrarResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      BuyDomainsDomainsRegistrarResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'BuyDomainsDomainsRegistrarResponseBody' from JSON`,
  );
}

/** @internal */
export const BuyDomainsMethod$inboundSchema: z.ZodNativeEnum<
  typeof BuyDomainsMethod
> = z.nativeEnum(BuyDomainsMethod);

/** @internal */
export const BuyDomainsLinks$inboundSchema: z.ZodType<
  BuyDomainsLinks,
  z.ZodTypeDef,
  unknown
> = z.object({
  href: types.string(),
  method: BuyDomainsMethod$inboundSchema,
});

export function buyDomainsLinksFromJSON(
  jsonString: string,
): SafeParseResult<BuyDomainsLinks, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => BuyDomainsLinks$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'BuyDomainsLinks' from JSON`,
  );
}

/** @internal */
export const BuyDomainsResponseBody$inboundSchema: z.ZodType<
  BuyDomainsResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  orderId: types.string(),
  _links: z.record(z.lazy(() => BuyDomainsLinks$inboundSchema)),
}).transform((v) => {
  return remap$(v, {
    "_links": "links",
  });
});

export function buyDomainsResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<BuyDomainsResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => BuyDomainsResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'BuyDomainsResponseBody' from JSON`,
  );
}