@vercel/sdk 1.13.3 → 1.13.4

package/src/models/renewdomainop.ts

@@ -8,11 +8,41 @@ import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
-  InternalServerError,
-  InternalServerError$inboundSchema,
-  InternalServerError$Outbound,
-  InternalServerError$outboundSchema,
-} from "./internalservererror.js";
+  BadRequest,
+  BadRequest$inboundSchema,
+  BadRequest$Outbound,
+  BadRequest$outboundSchema,
+} from "./badrequest.js";
+import {
+  DomainNotAvailable,
+  DomainNotAvailable$inboundSchema,
+  DomainNotAvailable$Outbound,
+  DomainNotAvailable$outboundSchema,
+} from "./domainnotavailable.js";
+import {
+  DomainNotRegistered,
+  DomainNotRegistered$inboundSchema,
+  DomainNotRegistered$Outbound,
+  DomainNotRegistered$outboundSchema,
+} from "./domainnotregistered.js";
+import {
+  ExpectedPriceMismatch,
+  ExpectedPriceMismatch$inboundSchema,
+  ExpectedPriceMismatch$Outbound,
+  ExpectedPriceMismatch$outboundSchema,
+} from "./expectedpricemismatch.js";
+import {
+  Forbidden,
+  Forbidden$inboundSchema,
+  Forbidden$Outbound,
+  Forbidden$outboundSchema,
+} from "./forbidden.js";
+import {
+  HttpApiDecodeError,
+  HttpApiDecodeError$inboundSchema,
+  HttpApiDecodeError$Outbound,
+  HttpApiDecodeError$outboundSchema,
+} from "./httpapidecodeerror.js";
 import {
   NotAuthorizedForScope,
   NotAuthorizedForScope$inboundSchema,
@@ -21,11 +51,11 @@ import {
 } from "./notauthorizedforscope.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
 import {
-  Unauthorized,
-  Unauthorized$inboundSchema,
-  Unauthorized$Outbound,
-  Unauthorized$outboundSchema,
-} from "./unauthorized.js";
+  TldNotSupported,
+  TldNotSupported$inboundSchema,
+  TldNotSupported$Outbound,
+  TldNotSupported$outboundSchema,
+} from "./tldnotsupported.js";
 
 export type RenewDomainContactInformation = {
   /**
@@ -93,12 +123,22 @@ export type RenewDomainRequest = {
 };
 
 /**
- * Unauthorized
+ * NotAuthorizedForScope
  */
-export type RenewDomainDomainsRegistrarResponseBody =
-  | Unauthorized
+export type RenewDomainDomainsRegistrarResponseResponseBody =
   | NotAuthorizedForScope
-  | InternalServerError;
+  | Forbidden;
+
+/**
+ * There was something wrong with the request
+ */
+export type RenewDomainDomainsRegistrarResponseBody =
+  | HttpApiDecodeError
+  | TldNotSupported
+  | DomainNotAvailable
+  | ExpectedPriceMismatch
+  | DomainNotRegistered
+  | BadRequest;
 
 export const RenewDomainMethod = {
   Get: "GET",
@@ -338,22 +378,92 @@ export function renewDomainRequestFromJSON(
   );
 }
 
+/** @internal */
+export const RenewDomainDomainsRegistrarResponseResponseBody$inboundSchema:
+  z.ZodType<
+    RenewDomainDomainsRegistrarResponseResponseBody,
+    z.ZodTypeDef,
+    unknown
+  > = z.union([NotAuthorizedForScope$inboundSchema, Forbidden$inboundSchema]);
+
+/** @internal */
+export type RenewDomainDomainsRegistrarResponseResponseBody$Outbound =
+  | NotAuthorizedForScope$Outbound
+  | Forbidden$Outbound;
+
+/** @internal */
+export const RenewDomainDomainsRegistrarResponseResponseBody$outboundSchema:
+  z.ZodType<
+    RenewDomainDomainsRegistrarResponseResponseBody$Outbound,
+    z.ZodTypeDef,
+    RenewDomainDomainsRegistrarResponseResponseBody
+  > = z.union([NotAuthorizedForScope$outboundSchema, Forbidden$outboundSchema]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace RenewDomainDomainsRegistrarResponseResponseBody$ {
+  /** @deprecated use `RenewDomainDomainsRegistrarResponseResponseBody$inboundSchema` instead. */
+  export const inboundSchema =
+    RenewDomainDomainsRegistrarResponseResponseBody$inboundSchema;
+  /** @deprecated use `RenewDomainDomainsRegistrarResponseResponseBody$outboundSchema` instead. */
+  export const outboundSchema =
+    RenewDomainDomainsRegistrarResponseResponseBody$outboundSchema;
+  /** @deprecated use `RenewDomainDomainsRegistrarResponseResponseBody$Outbound` instead. */
+  export type Outbound =
+    RenewDomainDomainsRegistrarResponseResponseBody$Outbound;
+}
+
+export function renewDomainDomainsRegistrarResponseResponseBodyToJSON(
+  renewDomainDomainsRegistrarResponseResponseBody:
+    RenewDomainDomainsRegistrarResponseResponseBody,
+): string {
+  return JSON.stringify(
+    RenewDomainDomainsRegistrarResponseResponseBody$outboundSchema.parse(
+      renewDomainDomainsRegistrarResponseResponseBody,
+    ),
+  );
+}
+
+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
 > = z.union([
-  Unauthorized$inboundSchema,
-  NotAuthorizedForScope$inboundSchema,
-  InternalServerError$inboundSchema,
+  HttpApiDecodeError$inboundSchema,
+  TldNotSupported$inboundSchema,
+  DomainNotAvailable$inboundSchema,
+  ExpectedPriceMismatch$inboundSchema,
+  DomainNotRegistered$inboundSchema,
+  BadRequest$inboundSchema,
 ]);
 
 /** @internal */
 export type RenewDomainDomainsRegistrarResponseBody$Outbound =
-  | Unauthorized$Outbound
-  | NotAuthorizedForScope$Outbound
-  | InternalServerError$Outbound;
+  | HttpApiDecodeError$Outbound
+  | TldNotSupported$Outbound
+  | DomainNotAvailable$Outbound
+  | ExpectedPriceMismatch$Outbound
+  | DomainNotRegistered$Outbound
+  | BadRequest$Outbound;
 
 /** @internal */
 export const RenewDomainDomainsRegistrarResponseBody$outboundSchema: z.ZodType<
@@ -361,9 +471,12 @@ export const RenewDomainDomainsRegistrarResponseBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   RenewDomainDomainsRegistrarResponseBody
 > = z.union([
-  Unauthorized$outboundSchema,
-  NotAuthorizedForScope$outboundSchema,
-  InternalServerError$outboundSchema,
+  HttpApiDecodeError$outboundSchema,
+  TldNotSupported$outboundSchema,
+  DomainNotAvailable$outboundSchema,
+  ExpectedPriceMismatch$outboundSchema,
+  DomainNotRegistered$outboundSchema,
+  BadRequest$outboundSchema,
 ]);
 
 /**

package/src/models/tldnotsupported.ts

@@ -0,0 +1,157 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ClosedEnum } from "../types/enums.js";
+import { VercelError } from "./vercelerror.js";
+
+export const TldNotSupportedCode = {
+  TldNotSupported: "tld_not_supported",
+} as const;
+export type TldNotSupportedCode = ClosedEnum<typeof TldNotSupportedCode>;
+
+export const TldNotSupportedTag = {
+  TldNotSupported: "TldNotSupported",
+} as const;
+export type TldNotSupportedTag = ClosedEnum<typeof TldNotSupportedTag>;
+
+export type TldNotSupportedData = {
+  status: number;
+  code: TldNotSupportedCode;
+  message: string;
+  tag: TldNotSupportedTag;
+};
+
+export class TldNotSupported extends VercelError {
+  status: number;
+  code: TldNotSupportedCode;
+  tag: TldNotSupportedTag;
+
+  /** The original data that was passed to this error instance. */
+  data$: TldNotSupportedData;
+
+  constructor(
+    err: TldNotSupportedData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.status = err.status;
+    this.code = err.code;
+    this.tag = err.tag;
+
+    this.name = "TldNotSupported";
+  }
+}
+
+/** @internal */
+export const TldNotSupportedCode$inboundSchema: z.ZodNativeEnum<
+  typeof TldNotSupportedCode
+> = z.nativeEnum(TldNotSupportedCode);
+
+/** @internal */
+export const TldNotSupportedCode$outboundSchema: z.ZodNativeEnum<
+  typeof TldNotSupportedCode
+> = TldNotSupportedCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TldNotSupportedCode$ {
+  /** @deprecated use `TldNotSupportedCode$inboundSchema` instead. */
+  export const inboundSchema = TldNotSupportedCode$inboundSchema;
+  /** @deprecated use `TldNotSupportedCode$outboundSchema` instead. */
+  export const outboundSchema = TldNotSupportedCode$outboundSchema;
+}
+
+/** @internal */
+export const TldNotSupportedTag$inboundSchema: z.ZodNativeEnum<
+  typeof TldNotSupportedTag
+> = z.nativeEnum(TldNotSupportedTag);
+
+/** @internal */
+export const TldNotSupportedTag$outboundSchema: z.ZodNativeEnum<
+  typeof TldNotSupportedTag
+> = TldNotSupportedTag$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TldNotSupportedTag$ {
+  /** @deprecated use `TldNotSupportedTag$inboundSchema` instead. */
+  export const inboundSchema = TldNotSupportedTag$inboundSchema;
+  /** @deprecated use `TldNotSupportedTag$outboundSchema` instead. */
+  export const outboundSchema = TldNotSupportedTag$outboundSchema;
+}
+
+/** @internal */
+export const TldNotSupported$inboundSchema: z.ZodType<
+  TldNotSupported,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: z.number(),
+  code: TldNotSupportedCode$inboundSchema,
+  message: z.string(),
+  _tag: TldNotSupportedTag$inboundSchema,
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    const remapped = remap$(v, {
+      "_tag": "tag",
+    });
+
+    return new TldNotSupported(remapped, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type TldNotSupported$Outbound = {
+  status: number;
+  code: string;
+  message: string;
+  _tag: string;
+};
+
+/** @internal */
+export const TldNotSupported$outboundSchema: z.ZodType<
+  TldNotSupported$Outbound,
+  z.ZodTypeDef,
+  TldNotSupported
+> = z.instanceof(TldNotSupported)
+  .transform(v => v.data$)
+  .pipe(
+    z.object({
+      status: z.number(),
+      code: TldNotSupportedCode$outboundSchema,
+      message: z.string(),
+      tag: TldNotSupportedTag$outboundSchema,
+    }).transform((v) => {
+      return remap$(v, {
+        tag: "_tag",
+      });
+    }),
+  );
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TldNotSupported$ {
+  /** @deprecated use `TldNotSupported$inboundSchema` instead. */
+  export const inboundSchema = TldNotSupported$inboundSchema;
+  /** @deprecated use `TldNotSupported$outboundSchema` instead. */
+  export const outboundSchema = TldNotSupported$outboundSchema;
+  /** @deprecated use `TldNotSupported$Outbound` instead. */
+  export type Outbound = TldNotSupported$Outbound;
+}

package/src/models/toomanydomains.ts

@@ -0,0 +1,157 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ClosedEnum } from "../types/enums.js";
+import { VercelError } from "./vercelerror.js";
+
+export const TooManyDomainsCode = {
+  TooManyDomains: "too_many_domains",
+} as const;
+export type TooManyDomainsCode = ClosedEnum<typeof TooManyDomainsCode>;
+
+export const TooManyDomainsTag = {
+  TooManyDomains: "TooManyDomains",
+} as const;
+export type TooManyDomainsTag = ClosedEnum<typeof TooManyDomainsTag>;
+
+export type TooManyDomainsData = {
+  status: number;
+  code: TooManyDomainsCode;
+  message: string;
+  tag: TooManyDomainsTag;
+};
+
+export class TooManyDomains extends VercelError {
+  status: number;
+  code: TooManyDomainsCode;
+  tag: TooManyDomainsTag;
+
+  /** The original data that was passed to this error instance. */
+  data$: TooManyDomainsData;
+
+  constructor(
+    err: TooManyDomainsData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.status = err.status;
+    this.code = err.code;
+    this.tag = err.tag;
+
+    this.name = "TooManyDomains";
+  }
+}
+
+/** @internal */
+export const TooManyDomainsCode$inboundSchema: z.ZodNativeEnum<
+  typeof TooManyDomainsCode
+> = z.nativeEnum(TooManyDomainsCode);
+
+/** @internal */
+export const TooManyDomainsCode$outboundSchema: z.ZodNativeEnum<
+  typeof TooManyDomainsCode
+> = TooManyDomainsCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TooManyDomainsCode$ {
+  /** @deprecated use `TooManyDomainsCode$inboundSchema` instead. */
+  export const inboundSchema = TooManyDomainsCode$inboundSchema;
+  /** @deprecated use `TooManyDomainsCode$outboundSchema` instead. */
+  export const outboundSchema = TooManyDomainsCode$outboundSchema;
+}
+
+/** @internal */
+export const TooManyDomainsTag$inboundSchema: z.ZodNativeEnum<
+  typeof TooManyDomainsTag
+> = z.nativeEnum(TooManyDomainsTag);
+
+/** @internal */
+export const TooManyDomainsTag$outboundSchema: z.ZodNativeEnum<
+  typeof TooManyDomainsTag
+> = TooManyDomainsTag$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TooManyDomainsTag$ {
+  /** @deprecated use `TooManyDomainsTag$inboundSchema` instead. */
+  export const inboundSchema = TooManyDomainsTag$inboundSchema;
+  /** @deprecated use `TooManyDomainsTag$outboundSchema` instead. */
+  export const outboundSchema = TooManyDomainsTag$outboundSchema;
+}
+
+/** @internal */
+export const TooManyDomains$inboundSchema: z.ZodType<
+  TooManyDomains,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: z.number(),
+  code: TooManyDomainsCode$inboundSchema,
+  message: z.string(),
+  _tag: TooManyDomainsTag$inboundSchema,
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    const remapped = remap$(v, {
+      "_tag": "tag",
+    });
+
+    return new TooManyDomains(remapped, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type TooManyDomains$Outbound = {
+  status: number;
+  code: string;
+  message: string;
+  _tag: string;
+};
+
+/** @internal */
+export const TooManyDomains$outboundSchema: z.ZodType<
+  TooManyDomains$Outbound,
+  z.ZodTypeDef,
+  TooManyDomains
+> = z.instanceof(TooManyDomains)
+  .transform(v => v.data$)
+  .pipe(
+    z.object({
+      status: z.number(),
+      code: TooManyDomainsCode$outboundSchema,
+      message: z.string(),
+      tag: TooManyDomainsTag$outboundSchema,
+    }).transform((v) => {
+      return remap$(v, {
+        tag: "_tag",
+      });
+    }),
+  );
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TooManyDomains$ {
+  /** @deprecated use `TooManyDomains$inboundSchema` instead. */
+  export const inboundSchema = TooManyDomains$inboundSchema;
+  /** @deprecated use `TooManyDomains$outboundSchema` instead. */
+  export const outboundSchema = TooManyDomains$outboundSchema;
+  /** @deprecated use `TooManyDomains$Outbound` instead. */
+  export type Outbound = TooManyDomains$Outbound;
+}