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

import * as z from "zod/v3";
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 { Forbidden, Forbidden$inboundSchema } from "./forbidden.js";
import {
  NotAuthorizedForScope,
  NotAuthorizedForScope$inboundSchema,
} from "./notauthorizedforscope.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

export type GetOrderRequest = {
  orderId: string;
  teamId?: string | undefined;
};

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

export const GetOrderDomainsDomainsRegistrarStatus = {
  Pending: "pending",
  Completed: "completed",
  Failed: "failed",
  Refunded: "refunded",
  RefundFailed: "refund-failed",
} as const;
export type GetOrderDomainsDomainsRegistrarStatus = ClosedEnum<
  typeof GetOrderDomainsDomainsRegistrarStatus
>;

export type GetOrderErrorDomainsRegistrar2 = {
  code: string;
  details?: any | undefined;
};

export const GetOrder1InvalidField = {
  FirstName: "firstName",
  LastName: "lastName",
  Email: "email",
  Phone: "phone",
  Address1: "address1",
  Address2: "address2",
  City: "city",
  State: "state",
  Zip: "zip",
  Country: "country",
  CompanyName: "companyName",
  Fax: "fax",
} as const;
export type GetOrder1InvalidField = ClosedEnum<typeof GetOrder1InvalidField>;

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Error10Details =
  {
    invalidField?: GetOrder1InvalidField | undefined;
  };

export type GetOrder1DomainsRegistrar10 = {
  code: "invalid-contact";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Error10Details;
};

export type GetOrder1DomainsRegistrar9 = {
  code: "unavailable-legal";
};

export type GetOrder1DomainsRegistrar8 = {
  code: "price-change";
};

export type GetOrder1DomainsRegistrar7 = {
  code: "account-transfer-required";
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3ErrorDetails =
  {
    numDaysUntilTransferrable: number;
  };

export type GetOrder1DomainsRegistrar6 = {
  code: "cannot-transfer-in-until";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3ErrorDetails;
};

export type GetOrder1DomainsRegistrar5 = {
  code: "claims-notice-required";
};

export type GetOrder1DomainsRegistrar4 = {
  code: "incorrect-auth-code";
};

export type GetOrder1DomainsRegistrar3 = {
  code: "client-transfer-prohibited";
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Details =
  {
    detectedLanguageCode: string;
  };

export type GetOrder1DomainsRegistrar2 = {
  code: "incorrect-language-code";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Details;
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomainsDetails =
  {
    detectedLanguageCode: string;
  };

export type GetOrder1DomainsRegistrar1 = {
  code: "unsupported-language-code";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomainsDetails;
};

export type GetOrderErrorDomainsRegistrar1 =
  | GetOrder1DomainsRegistrar1
  | GetOrder1DomainsRegistrar2
  | GetOrder1DomainsRegistrar3
  | GetOrder1DomainsRegistrar4
  | GetOrder1DomainsRegistrar5
  | GetOrder1DomainsRegistrar6
  | GetOrder1DomainsRegistrar7
  | GetOrder1DomainsRegistrar8
  | GetOrder1DomainsRegistrar9
  | GetOrder1DomainsRegistrar10;

export type GetOrderDomainsDomainsRegistrarError =
  | GetOrderErrorDomainsRegistrar2
  | GetOrder1DomainsRegistrar1
  | GetOrder1DomainsRegistrar2
  | GetOrder1DomainsRegistrar3
  | GetOrder1DomainsRegistrar4
  | GetOrder1DomainsRegistrar5
  | GetOrder1DomainsRegistrar6
  | GetOrder1DomainsRegistrar7
  | GetOrder1DomainsRegistrar8
  | GetOrder1DomainsRegistrar9
  | GetOrder1DomainsRegistrar10;

export type Domains3 = {
  purchaseType: "transfer";
  autoRenew: boolean;
  /**
   * The number of years the domain is being transferred for.
   */
  years: number;
  /**
   * A valid domain name
   */
  domainName: string;
  status: GetOrderDomainsDomainsRegistrarStatus;
  price: number;
  error?:
    | GetOrderErrorDomainsRegistrar2
    | GetOrder1DomainsRegistrar1
    | GetOrder1DomainsRegistrar2
    | GetOrder1DomainsRegistrar3
    | GetOrder1DomainsRegistrar4
    | GetOrder1DomainsRegistrar5
    | GetOrder1DomainsRegistrar6
    | GetOrder1DomainsRegistrar7
    | GetOrder1DomainsRegistrar8
    | GetOrder1DomainsRegistrar9
    | GetOrder1DomainsRegistrar10
    | undefined;
};

export const GetOrderDomainsStatus = {
  Pending: "pending",
  Completed: "completed",
  Failed: "failed",
  Refunded: "refunded",
  RefundFailed: "refund-failed",
} as const;
export type GetOrderDomainsStatus = ClosedEnum<typeof GetOrderDomainsStatus>;

export type GetOrderError2 = {
  code: string;
  details?: any | undefined;
};

export const OneInvalidField = {
  FirstName: "firstName",
  LastName: "lastName",
  Email: "email",
  Phone: "phone",
  Address1: "address1",
  Address2: "address2",
  City: "city",
  State: "state",
  Zip: "zip",
  Country: "country",
  CompanyName: "companyName",
  Fax: "fax",
} as const;
export type OneInvalidField = ClosedEnum<typeof OneInvalidField>;

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDetails =
  {
    invalidField?: OneInvalidField | undefined;
  };

export type GetOrder110 = {
  code: "invalid-contact";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDetails;
};

export type GetOrder19 = {
  code: "unavailable-legal";
};

export type GetOrder18 = {
  code: "price-change";
};

export type GetOrder17 = {
  code: "account-transfer-required";
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONDetails = {
  numDaysUntilTransferrable: number;
};

export type GetOrder16 = {
  code: "cannot-transfer-in-until";
  details: GetOrder1DomainsRegistrarResponse200ApplicationJSONDetails;
};

export type GetOrder15 = {
  code: "claims-notice-required";
};

export type GetOrder14 = {
  code: "incorrect-auth-code";
};

export type GetOrder1DomainsRegistrarResponse2003 = {
  code: "client-transfer-prohibited";
};

export type GetOrder1DomainsRegistrarResponse200Details = {
  detectedLanguageCode: string;
};

export type GetOrder1DomainsRegistrarResponse2002 = {
  code: "incorrect-language-code";
  details: GetOrder1DomainsRegistrarResponse200Details;
};

export type GetOrder1DomainsRegistrarResponseDetails = {
  detectedLanguageCode: string;
};

export type GetOrder1DomainsRegistrarResponse2001 = {
  code: "unsupported-language-code";
  details: GetOrder1DomainsRegistrarResponseDetails;
};

export type GetOrderError1 =
  | GetOrder1DomainsRegistrarResponse2001
  | GetOrder1DomainsRegistrarResponse2002
  | GetOrder1DomainsRegistrarResponse2003
  | GetOrder14
  | GetOrder15
  | GetOrder16
  | GetOrder17
  | GetOrder18
  | GetOrder19
  | GetOrder110;

export type GetOrderDomainsError =
  | GetOrderError2
  | GetOrder1DomainsRegistrarResponse2001
  | GetOrder1DomainsRegistrarResponse2002
  | GetOrder1DomainsRegistrarResponse2003
  | GetOrder14
  | GetOrder15
  | GetOrder16
  | GetOrder17
  | GetOrder18
  | GetOrder19
  | GetOrder110;

export type Domains2 = {
  purchaseType: "renewal";
  /**
   * The number of years the domain is being renewed for.
   */
  years: number;
  /**
   * A valid domain name
   */
  domainName: string;
  status: GetOrderDomainsStatus;
  price: number;
  error?:
    | GetOrderError2
    | GetOrder1DomainsRegistrarResponse2001
    | GetOrder1DomainsRegistrarResponse2002
    | GetOrder1DomainsRegistrarResponse2003
    | GetOrder14
    | GetOrder15
    | GetOrder16
    | GetOrder17
    | GetOrder18
    | GetOrder19
    | GetOrder110
    | undefined;
};

export const DomainsStatus = {
  Pending: "pending",
  Completed: "completed",
  Failed: "failed",
  Refunded: "refunded",
  RefundFailed: "refund-failed",
} as const;
export type DomainsStatus = ClosedEnum<typeof DomainsStatus>;

export type GetOrderErrorDomainsRegistrarResponse2 = {
  code: string;
  details?: any | undefined;
};

export const InvalidField = {
  FirstName: "firstName",
  LastName: "lastName",
  Email: "email",
  Phone: "phone",
  Address1: "address1",
  Address2: "address2",
  City: "city",
  State: "state",
  Zip: "zip",
  Country: "country",
  CompanyName: "companyName",
  Fax: "fax",
} as const;
export type InvalidField = ClosedEnum<typeof InvalidField>;

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error10Details =
  {
    invalidField?: InvalidField | undefined;
  };

export type One10 = {
  code: "invalid-contact";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error10Details;
};

export type One9 = {
  code: "unavailable-legal";
};

export type One8 = {
  code: "price-change";
};

export type One7 = {
  code: "account-transfer-required";
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error6Details =
  {
    numDaysUntilTransferrable: number;
  };

export type GetOrder1DomainsRegistrarResponse6 = {
  code: "cannot-transfer-in-until";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error6Details;
};

export type GetOrder1DomainsRegistrarResponse5 = {
  code: "claims-notice-required";
};

export type GetOrder1DomainsRegistrarResponse4 = {
  code: "incorrect-auth-code";
};

export type GetOrder1DomainsRegistrarResponse3 = {
  code: "client-transfer-prohibited";
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1ErrorDetails =
  {
    detectedLanguageCode: string;
  };

export type GetOrder1DomainsRegistrarResponse2 = {
  code: "incorrect-language-code";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1ErrorDetails;
};

export type GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Details =
  {
    detectedLanguageCode: string;
  };

export type GetOrder1DomainsRegistrarResponse1 = {
  code: "unsupported-language-code";
  details:
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Details;
};

export type GetOrderErrorDomainsRegistrarResponse1 =
  | GetOrder1DomainsRegistrarResponse1
  | GetOrder1DomainsRegistrarResponse2
  | GetOrder1DomainsRegistrarResponse3
  | GetOrder1DomainsRegistrarResponse4
  | GetOrder1DomainsRegistrarResponse5
  | GetOrder1DomainsRegistrarResponse6
  | One7
  | One8
  | One9
  | One10;

export type DomainsError =
  | GetOrderErrorDomainsRegistrarResponse2
  | GetOrder1DomainsRegistrarResponse1
  | GetOrder1DomainsRegistrarResponse2
  | GetOrder1DomainsRegistrarResponse3
  | GetOrder1DomainsRegistrarResponse4
  | GetOrder1DomainsRegistrarResponse5
  | GetOrder1DomainsRegistrarResponse6
  | One7
  | One8
  | One9
  | One10;

export type Domains1 = {
  purchaseType: "purchase";
  autoRenew: boolean;
  /**
   * The number of years the domain is being purchased for.
   */
  years: number;
  /**
   * A valid domain name
   */
  domainName: string;
  status: DomainsStatus;
  price: number;
  error?:
    | GetOrderErrorDomainsRegistrarResponse2
    | GetOrder1DomainsRegistrarResponse1
    | GetOrder1DomainsRegistrarResponse2
    | GetOrder1DomainsRegistrarResponse3
    | GetOrder1DomainsRegistrarResponse4
    | GetOrder1DomainsRegistrarResponse5
    | GetOrder1DomainsRegistrarResponse6
    | One7
    | One8
    | One9
    | One10
    | undefined;
};

export type GetOrderDomains = Domains1 | Domains2 | Domains3;

export const GetOrderStatus = {
  Draft: "draft",
  Purchasing: "purchasing",
  Completed: "completed",
  Failed: "failed",
} as const;
export type GetOrderStatus = ClosedEnum<typeof GetOrderStatus>;

export type Error2 = {
  code: string;
  details?: any | undefined;
};

export type One6 = {
  code: "domain-mismatch";
};

export type GetOrder1Details = {
  message: string;
  domainNames: Array<string>;
};

export type One5 = {
  code: "claims-required";
  details: GetOrder1Details;
};

export type One4 = {
  code: "unexpected-error";
};

export type OneDetails = {
  expectedPrice: number;
  actualPrice?: number | undefined;
};

export type GetOrder13 = {
  code: "price-mismatch";
  details: OneDetails;
};

export type Tlds = {
  tldName: string;
  endsAt: string;
};

export type GetOrder1DomainsRegistrarDetails = {
  tlds: Array<Tlds>;
};

export type GetOrder12 = {
  code: "tld-outage";
  details: GetOrder1DomainsRegistrarDetails;
};

export type GetOrder11 = {
  code: "payment-failed";
};

export type Error1 = GetOrder11 | GetOrder12 | GetOrder13 | One4 | One5 | One6;

export type ErrorT =
  | Error2
  | GetOrder11
  | GetOrder12
  | GetOrder13
  | One4
  | One5
  | One6;

/**
 * Success
 */
export type GetOrderResponseBody = {
  /**
   * A valid order ID
   */
  orderId: string;
  domains: Array<Domains1 | Domains2 | Domains3>;
  status: GetOrderStatus;
  error?:
    | Error2
    | GetOrder11
    | GetOrder12
    | GetOrder13
    | One4
    | One5
    | One6
    | undefined;
};

/** @internal */
export type GetOrderRequest$Outbound = {
  orderId: string;
  teamId?: string | undefined;
};

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

export function getOrderRequestToJSON(
  getOrderRequest: GetOrderRequest,
): string {
  return JSON.stringify(GetOrderRequest$outboundSchema.parse(getOrderRequest));
}

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

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

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

/** @internal */
export const GetOrderErrorDomainsRegistrar2$inboundSchema: z.ZodType<
  GetOrderErrorDomainsRegistrar2,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.string(),
  details: types.optional(z.any()),
});

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Error10Details$inboundSchema:
  z.ZodType<
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Error10Details,
    z.ZodTypeDef,
    unknown
  > = z.object({
    invalidField: types.optional(GetOrder1InvalidField$inboundSchema),
  });

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

/** @internal */
export const GetOrder1DomainsRegistrar10$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar10,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("invalid-contact"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Error10Details$inboundSchema
  ),
});

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

/** @internal */
export const GetOrder1DomainsRegistrar9$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar9,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("unavailable-legal"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrar8$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar8,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("price-change"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrar7$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar7,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("account-transfer-required"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3ErrorDetails$inboundSchema:
  z.ZodType<
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3ErrorDetails,
    z.ZodTypeDef,
    unknown
  > = z.object({
    numDaysUntilTransferrable: types.number(),
  });

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

/** @internal */
export const GetOrder1DomainsRegistrar6$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar6,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("cannot-transfer-in-until"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3ErrorDetails$inboundSchema
  ),
});

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

/** @internal */
export const GetOrder1DomainsRegistrar5$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar5,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("claims-notice-required"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrar4$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar4,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("incorrect-auth-code"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrar3$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar3,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("client-transfer-prohibited"),
});

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

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

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

/** @internal */
export const GetOrder1DomainsRegistrar2$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar2,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("incorrect-language-code"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains3Details$inboundSchema
  ),
});

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

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

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

/** @internal */
export const GetOrder1DomainsRegistrar1$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrar1,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("unsupported-language-code"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomainsDetails$inboundSchema
  ),
});

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

/** @internal */
export const GetOrderErrorDomainsRegistrar1$inboundSchema: z.ZodType<
  GetOrderErrorDomainsRegistrar1,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetOrder1DomainsRegistrar1$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar2$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar3$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar4$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar5$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar6$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar7$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar8$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar9$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrar10$inboundSchema),
]);

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

/** @internal */
export const GetOrderDomainsDomainsRegistrarError$inboundSchema: z.ZodType<
  GetOrderDomainsDomainsRegistrarError,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetOrderErrorDomainsRegistrar2$inboundSchema),
  z.union([
    z.lazy(() => GetOrder1DomainsRegistrar1$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar2$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar3$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar4$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar5$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar6$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar7$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar8$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar9$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrar10$inboundSchema),
  ]),
]);

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

/** @internal */
export const Domains3$inboundSchema: z.ZodType<
  Domains3,
  z.ZodTypeDef,
  unknown
> = z.object({
  purchaseType: types.literal("transfer"),
  autoRenew: types.boolean(),
  years: types.number(),
  domainName: types.string(),
  status: GetOrderDomainsDomainsRegistrarStatus$inboundSchema,
  price: types.number(),
  error: types.optional(
    smartUnion([
      z.lazy(() => GetOrderErrorDomainsRegistrar2$inboundSchema),
      z.union([
        z.lazy(() => GetOrder1DomainsRegistrar1$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar2$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar3$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar4$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar5$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar6$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar7$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar8$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar9$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrar10$inboundSchema),
      ]),
    ]),
  ),
});

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

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

/** @internal */
export const GetOrderError2$inboundSchema: z.ZodType<
  GetOrderError2,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.string(),
  details: types.optional(z.any()),
});

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDetails$inboundSchema:
  z.ZodType<
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDetails,
    z.ZodTypeDef,
    unknown
  > = z.object({
    invalidField: types.optional(OneInvalidField$inboundSchema),
  });

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

/** @internal */
export const GetOrder110$inboundSchema: z.ZodType<
  GetOrder110,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("invalid-contact"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDetails$inboundSchema
  ),
});

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

/** @internal */
export const GetOrder19$inboundSchema: z.ZodType<
  GetOrder19,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("unavailable-legal"),
});

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

/** @internal */
export const GetOrder18$inboundSchema: z.ZodType<
  GetOrder18,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("price-change"),
});

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

/** @internal */
export const GetOrder17$inboundSchema: z.ZodType<
  GetOrder17,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("account-transfer-required"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse200ApplicationJSONDetails$inboundSchema:
  z.ZodType<
    GetOrder1DomainsRegistrarResponse200ApplicationJSONDetails,
    z.ZodTypeDef,
    unknown
  > = z.object({
    numDaysUntilTransferrable: types.number(),
  });

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

/** @internal */
export const GetOrder16$inboundSchema: z.ZodType<
  GetOrder16,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("cannot-transfer-in-until"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONDetails$inboundSchema
  ),
});

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

/** @internal */
export const GetOrder15$inboundSchema: z.ZodType<
  GetOrder15,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("claims-notice-required"),
});

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

/** @internal */
export const GetOrder14$inboundSchema: z.ZodType<
  GetOrder14,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("incorrect-auth-code"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse2003$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse2003,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("client-transfer-prohibited"),
});

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

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse2002$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse2002,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("incorrect-language-code"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200Details$inboundSchema
  ),
});

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

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse2001$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse2001,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("unsupported-language-code"),
  details: z.lazy(() => GetOrder1DomainsRegistrarResponseDetails$inboundSchema),
});

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

/** @internal */
export const GetOrderError1$inboundSchema: z.ZodType<
  GetOrderError1,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetOrder1DomainsRegistrarResponse2001$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse2002$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse2003$inboundSchema),
  z.lazy(() => GetOrder14$inboundSchema),
  z.lazy(() => GetOrder15$inboundSchema),
  z.lazy(() => GetOrder16$inboundSchema),
  z.lazy(() => GetOrder17$inboundSchema),
  z.lazy(() => GetOrder18$inboundSchema),
  z.lazy(() => GetOrder19$inboundSchema),
  z.lazy(() => GetOrder110$inboundSchema),
]);

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

/** @internal */
export const GetOrderDomainsError$inboundSchema: z.ZodType<
  GetOrderDomainsError,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetOrderError2$inboundSchema),
  z.union([
    z.lazy(() => GetOrder1DomainsRegistrarResponse2001$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse2002$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse2003$inboundSchema),
    z.lazy(() => GetOrder14$inboundSchema),
    z.lazy(() => GetOrder15$inboundSchema),
    z.lazy(() => GetOrder16$inboundSchema),
    z.lazy(() => GetOrder17$inboundSchema),
    z.lazy(() => GetOrder18$inboundSchema),
    z.lazy(() => GetOrder19$inboundSchema),
    z.lazy(() => GetOrder110$inboundSchema),
  ]),
]);

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

/** @internal */
export const Domains2$inboundSchema: z.ZodType<
  Domains2,
  z.ZodTypeDef,
  unknown
> = z.object({
  purchaseType: types.literal("renewal"),
  years: types.number(),
  domainName: types.string(),
  status: GetOrderDomainsStatus$inboundSchema,
  price: types.number(),
  error: types.optional(
    smartUnion([
      z.lazy(() => GetOrderError2$inboundSchema),
      z.union([
        z.lazy(() => GetOrder1DomainsRegistrarResponse2001$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse2002$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse2003$inboundSchema),
        z.lazy(() => GetOrder14$inboundSchema),
        z.lazy(() => GetOrder15$inboundSchema),
        z.lazy(() => GetOrder16$inboundSchema),
        z.lazy(() => GetOrder17$inboundSchema),
        z.lazy(() => GetOrder18$inboundSchema),
        z.lazy(() => GetOrder19$inboundSchema),
        z.lazy(() => GetOrder110$inboundSchema),
      ]),
    ]),
  ),
});

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

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

/** @internal */
export const GetOrderErrorDomainsRegistrarResponse2$inboundSchema: z.ZodType<
  GetOrderErrorDomainsRegistrarResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.string(),
  details: types.optional(z.any()),
});

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error10Details$inboundSchema:
  z.ZodType<
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error10Details,
    z.ZodTypeDef,
    unknown
  > = z.object({
    invalidField: types.optional(InvalidField$inboundSchema),
  });

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

/** @internal */
export const One10$inboundSchema: z.ZodType<One10, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("invalid-contact"),
    details: z.lazy(() =>
      GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error10Details$inboundSchema
    ),
  });

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

/** @internal */
export const One9$inboundSchema: z.ZodType<One9, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("unavailable-legal"),
  });

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

/** @internal */
export const One8$inboundSchema: z.ZodType<One8, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("price-change"),
  });

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

/** @internal */
export const One7$inboundSchema: z.ZodType<One7, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("account-transfer-required"),
  });

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error6Details$inboundSchema:
  z.ZodType<
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error6Details,
    z.ZodTypeDef,
    unknown
  > = z.object({
    numDaysUntilTransferrable: types.number(),
  });

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse6$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse6,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("cannot-transfer-in-until"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Error6Details$inboundSchema
  ),
});

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse5$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse5,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("claims-notice-required"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse4$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse4,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("incorrect-auth-code"),
});

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse3$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse3,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("client-transfer-prohibited"),
});

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

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse2$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse2,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("incorrect-language-code"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1ErrorDetails$inboundSchema
  ),
});

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

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

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

/** @internal */
export const GetOrder1DomainsRegistrarResponse1$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarResponse1,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("unsupported-language-code"),
  details: z.lazy(() =>
    GetOrder1DomainsRegistrarResponse200ApplicationJSONResponseBodyDomains1Details$inboundSchema
  ),
});

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

/** @internal */
export const GetOrderErrorDomainsRegistrarResponse1$inboundSchema: z.ZodType<
  GetOrderErrorDomainsRegistrarResponse1,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => GetOrder1DomainsRegistrarResponse1$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse2$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse3$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse4$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse5$inboundSchema),
  z.lazy(() => GetOrder1DomainsRegistrarResponse6$inboundSchema),
  z.lazy(() => One7$inboundSchema),
  z.lazy(() => One8$inboundSchema),
  z.lazy(() => One9$inboundSchema),
  z.lazy(() => One10$inboundSchema),
]);

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

/** @internal */
export const DomainsError$inboundSchema: z.ZodType<
  DomainsError,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetOrderErrorDomainsRegistrarResponse2$inboundSchema),
  z.union([
    z.lazy(() => GetOrder1DomainsRegistrarResponse1$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse2$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse3$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse4$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse5$inboundSchema),
    z.lazy(() => GetOrder1DomainsRegistrarResponse6$inboundSchema),
    z.lazy(() => One7$inboundSchema),
    z.lazy(() => One8$inboundSchema),
    z.lazy(() => One9$inboundSchema),
    z.lazy(() => One10$inboundSchema),
  ]),
]);

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

/** @internal */
export const Domains1$inboundSchema: z.ZodType<
  Domains1,
  z.ZodTypeDef,
  unknown
> = z.object({
  purchaseType: types.literal("purchase"),
  autoRenew: types.boolean(),
  years: types.number(),
  domainName: types.string(),
  status: DomainsStatus$inboundSchema,
  price: types.number(),
  error: types.optional(
    smartUnion([
      z.lazy(() => GetOrderErrorDomainsRegistrarResponse2$inboundSchema),
      z.union([
        z.lazy(() => GetOrder1DomainsRegistrarResponse1$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse2$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse3$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse4$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse5$inboundSchema),
        z.lazy(() => GetOrder1DomainsRegistrarResponse6$inboundSchema),
        z.lazy(() => One7$inboundSchema),
        z.lazy(() => One8$inboundSchema),
        z.lazy(() => One9$inboundSchema),
        z.lazy(() => One10$inboundSchema),
      ]),
    ]),
  ),
});

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

/** @internal */
export const GetOrderDomains$inboundSchema: z.ZodType<
  GetOrderDomains,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => Domains1$inboundSchema),
  z.lazy(() => Domains2$inboundSchema),
  z.lazy(() => Domains3$inboundSchema),
]);

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

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

/** @internal */
export const Error2$inboundSchema: z.ZodType<Error2, z.ZodTypeDef, unknown> = z
  .object({
    code: types.string(),
    details: types.optional(z.any()),
  });

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

/** @internal */
export const One6$inboundSchema: z.ZodType<One6, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("domain-mismatch"),
  });

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

/** @internal */
export const GetOrder1Details$inboundSchema: z.ZodType<
  GetOrder1Details,
  z.ZodTypeDef,
  unknown
> = z.object({
  message: types.string(),
  domainNames: z.array(types.string()),
});

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

/** @internal */
export const One5$inboundSchema: z.ZodType<One5, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("claims-required"),
    details: z.lazy(() => GetOrder1Details$inboundSchema),
  });

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

/** @internal */
export const One4$inboundSchema: z.ZodType<One4, z.ZodTypeDef, unknown> = z
  .object({
    code: types.literal("unexpected-error"),
  });

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

/** @internal */
export const OneDetails$inboundSchema: z.ZodType<
  OneDetails,
  z.ZodTypeDef,
  unknown
> = z.object({
  expectedPrice: types.number(),
  actualPrice: types.optional(types.number()),
});

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

/** @internal */
export const GetOrder13$inboundSchema: z.ZodType<
  GetOrder13,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("price-mismatch"),
  details: z.lazy(() => OneDetails$inboundSchema),
});

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

/** @internal */
export const Tlds$inboundSchema: z.ZodType<Tlds, z.ZodTypeDef, unknown> = z
  .object({
    tldName: types.string(),
    endsAt: types.string(),
  });

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

/** @internal */
export const GetOrder1DomainsRegistrarDetails$inboundSchema: z.ZodType<
  GetOrder1DomainsRegistrarDetails,
  z.ZodTypeDef,
  unknown
> = z.object({
  tlds: z.array(z.lazy(() => Tlds$inboundSchema)),
});

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

/** @internal */
export const GetOrder12$inboundSchema: z.ZodType<
  GetOrder12,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("tld-outage"),
  details: z.lazy(() => GetOrder1DomainsRegistrarDetails$inboundSchema),
});

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

/** @internal */
export const GetOrder11$inboundSchema: z.ZodType<
  GetOrder11,
  z.ZodTypeDef,
  unknown
> = z.object({
  code: types.literal("payment-failed"),
});

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

/** @internal */
export const Error1$inboundSchema: z.ZodType<Error1, z.ZodTypeDef, unknown> = z
  .union([
    z.lazy(() => GetOrder11$inboundSchema),
    z.lazy(() => GetOrder12$inboundSchema),
    z.lazy(() => GetOrder13$inboundSchema),
    z.lazy(() => One4$inboundSchema),
    z.lazy(() => One5$inboundSchema),
    z.lazy(() => One6$inboundSchema),
  ]);

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

/** @internal */
export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> =
  smartUnion([
    z.lazy(() => Error2$inboundSchema),
    z.union([
      z.lazy(() => GetOrder11$inboundSchema),
      z.lazy(() => GetOrder12$inboundSchema),
      z.lazy(() => GetOrder13$inboundSchema),
      z.lazy(() => One4$inboundSchema),
      z.lazy(() => One5$inboundSchema),
      z.lazy(() => One6$inboundSchema),
    ]),
  ]);

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

/** @internal */
export const GetOrderResponseBody$inboundSchema: z.ZodType<
  GetOrderResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  orderId: types.string(),
  domains: z.array(
    z.union([
      z.lazy(() => Domains1$inboundSchema),
      z.lazy(() => Domains2$inboundSchema),
      z.lazy(() => Domains3$inboundSchema),
    ]),
  ),
  status: GetOrderStatus$inboundSchema,
  error: types.optional(
    smartUnion([
      z.lazy(() => Error2$inboundSchema),
      z.union([
        z.lazy(() => GetOrder11$inboundSchema),
        z.lazy(() => GetOrder12$inboundSchema),
        z.lazy(() => GetOrder13$inboundSchema),
        z.lazy(() => One4$inboundSchema),
        z.lazy(() => One5$inboundSchema),
        z.lazy(() => One6$inboundSchema),
      ]),
    ]),
  ),
});

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