/*
 * 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 { BadRequest, BadRequest$inboundSchema } from "./badrequest.js";
import {
  DomainNotAvailable,
  DomainNotAvailable$inboundSchema,
} from "./domainnotavailable.js";
import {
  DomainNotRegistered,
  DomainNotRegistered$inboundSchema,
} from "./domainnotregistered.js";
import {
  DomainTooShort,
  DomainTooShort$inboundSchema,
} from "./domaintooshort.js";
import {
  ExpectedPriceMismatch,
  ExpectedPriceMismatch$inboundSchema,
} from "./expectedpricemismatch.js";
import { Forbidden, Forbidden$inboundSchema } from "./forbidden.js";
import {
  HttpApiDecodeError,
  HttpApiDecodeError$inboundSchema,
} from "./httpapidecodeerror.js";
import {
  NotAuthorizedForScope,
  NotAuthorizedForScope$inboundSchema,
} from "./notauthorizedforscope.js";
import { SDKValidationError } from "./sdkvalidationerror.js";
import {
  TldNotSupported,
  TldNotSupported$inboundSchema,
} from "./tldnotsupported.js";

export type RenewDomainContactInformation = {
  /**
   * 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;
};

export type RenewDomainRequestBody = {
  /**
   * The number of years to renew the domain for.
   */
  years: number;
  expectedPrice: number;
  contactInformation?: RenewDomainContactInformation | undefined;
};

export type RenewDomainRequest = {
  domain: string;
  teamId?: string | undefined;
  requestBody: RenewDomainRequestBody;
};

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

/**
 * There was something wrong with the request
 */
export type RenewDomainDomainsRegistrarResponseBody =
  | BadRequest
  | DomainTooShort
  | DomainNotRegistered
  | ExpectedPriceMismatch
  | DomainNotAvailable
  | TldNotSupported
  | HttpApiDecodeError;

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

export type RenewDomainLinks = {
  href: string;
  method: RenewDomainMethod;
};

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

/** @internal */
export type RenewDomainContactInformation$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;
};

/** @internal */
export const RenewDomainContactInformation$outboundSchema: z.ZodType<
  RenewDomainContactInformation$Outbound,
  z.ZodTypeDef,
  RenewDomainContactInformation
> = 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(),
});

export function renewDomainContactInformationToJSON(
  renewDomainContactInformation: RenewDomainContactInformation,
): string {
  return JSON.stringify(
    RenewDomainContactInformation$outboundSchema.parse(
      renewDomainContactInformation,
    ),
  );
}

/** @internal */
export type RenewDomainRequestBody$Outbound = {
  years: number;
  expectedPrice: number;
  contactInformation?: RenewDomainContactInformation$Outbound | undefined;
};

/** @internal */
export const RenewDomainRequestBody$outboundSchema: z.ZodType<
  RenewDomainRequestBody$Outbound,
  z.ZodTypeDef,
  RenewDomainRequestBody
> = z.object({
  years: z.number(),
  expectedPrice: z.number(),
  contactInformation: z.lazy(() => RenewDomainContactInformation$outboundSchema)
    .optional(),
});

export function renewDomainRequestBodyToJSON(
  renewDomainRequestBody: RenewDomainRequestBody,
): string {
  return JSON.stringify(
    RenewDomainRequestBody$outboundSchema.parse(renewDomainRequestBody),
  );
}

/** @internal */
export type RenewDomainRequest$Outbound = {
  domain: string;
  teamId?: string | undefined;
  RequestBody: RenewDomainRequestBody$Outbound;
};

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

export function renewDomainRequestToJSON(
  renewDomainRequest: RenewDomainRequest,
): string {
  return JSON.stringify(
    RenewDomainRequest$outboundSchema.parse(renewDomainRequest),
  );
}

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

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

/** @internal */
export const RenewDomainDomainsRegistrarResponseBody$inboundSchema: z.ZodType<
  RenewDomainDomainsRegistrarResponseBody,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  BadRequest$inboundSchema,
  DomainTooShort$inboundSchema,
  DomainNotRegistered$inboundSchema,
  ExpectedPriceMismatch$inboundSchema,
  DomainNotAvailable$inboundSchema,
  TldNotSupported$inboundSchema,
  HttpApiDecodeError$inboundSchema,
]);

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

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

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

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

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

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