@vercel/sdk 1.13.3 → 1.13.5

package/src/models/getorderop.ts

@@ -7,11 +7,11 @@ 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";
+  Forbidden,
+  Forbidden$inboundSchema,
+  Forbidden$Outbound,
+  Forbidden$outboundSchema,
+} from "./forbidden.js";
 import {
   NotAuthorizedForScope,
   NotAuthorizedForScope$inboundSchema,
@@ -19,24 +19,17 @@ import {
   NotAuthorizedForScope$outboundSchema,
 } from "./notauthorizedforscope.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
-import {
-  Unauthorized,
-  Unauthorized$inboundSchema,
-  Unauthorized$Outbound,
-  Unauthorized$outboundSchema,
-} from "./unauthorized.js";
 
 export type GetOrderRequest = {
   orderId: string;
 };
 
 /**
- * Unauthorized
+ * NotAuthorizedForScope
  */
 export type GetOrderDomainsRegistrarResponseBody =
-  | Unauthorized
   | NotAuthorizedForScope
-  | InternalServerError;
+  | Forbidden;
 
 export const GetOrderDomainsPurchaseType = {
   Transfer: "transfer",
@@ -62,7 +55,7 @@ export type Domains3 = {
   domainName: string;
   status: GetOrderDomainsDomainsRegistrarStatus;
   /**
-   * Represents a monetary amount in USD dollars
+   * The base TLD price for purchasing a domain for the given number of years. If null, the TLD does not support purchasing domains for the given number of years.
    */
   price: number;
   years: number;
@@ -87,7 +80,7 @@ export type Domains2 = {
   domainName: string;
   status: GetOrderDomainsStatus;
   /**
-   * Represents a monetary amount in USD dollars
+   * The base TLD price for purchasing a domain for the given number of years. If null, the TLD does not support purchasing domains for the given number of years.
    */
   price: number;
   years: number;
@@ -115,7 +108,7 @@ export type Domains1 = {
   domainName: string;
   status: DomainsStatus;
   /**
-   * Represents a monetary amount in USD dollars
+   * The base TLD price for purchasing a domain for the given number of years. If null, the TLD does not support purchasing domains for the given number of years.
    */
   price: number;
   years: number;
@@ -187,7 +180,7 @@ export type Error1 = {
   code: ErrorCode;
 };
 
-export type GetOrderError = Error2 | Error3 | Error1 | Error4;
+export type ErrorT = Error2 | Error3 | Error1 | Error4;
 
 /**
  * Success
@@ -256,28 +249,19 @@ export const GetOrderDomainsRegistrarResponseBody$inboundSchema: z.ZodType<
   GetOrderDomainsRegistrarResponseBody,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  Unauthorized$inboundSchema,
-  NotAuthorizedForScope$inboundSchema,
-  InternalServerError$inboundSchema,
-]);
+> = z.union([NotAuthorizedForScope$inboundSchema, Forbidden$inboundSchema]);
 
 /** @internal */
 export type GetOrderDomainsRegistrarResponseBody$Outbound =
-  | Unauthorized$Outbound
   | NotAuthorizedForScope$Outbound
-  | InternalServerError$Outbound;
+  | Forbidden$Outbound;
 
 /** @internal */
 export const GetOrderDomainsRegistrarResponseBody$outboundSchema: z.ZodType<
   GetOrderDomainsRegistrarResponseBody$Outbound,
   z.ZodTypeDef,
   GetOrderDomainsRegistrarResponseBody
-> = z.union([
-  Unauthorized$outboundSchema,
-  NotAuthorizedForScope$outboundSchema,
-  InternalServerError$outboundSchema,
-]);
+> = z.union([NotAuthorizedForScope$outboundSchema, Forbidden$outboundSchema]);
 
 /**
  * @internal
@@ -1150,29 +1134,26 @@ export function error1FromJSON(
 }
 
 /** @internal */
-export const GetOrderError$inboundSchema: z.ZodType<
-  GetOrderError,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => Error2$inboundSchema),
-  z.lazy(() => Error3$inboundSchema),
-  z.lazy(() => Error1$inboundSchema),
-  z.lazy(() => Error4$inboundSchema),
-]);
+export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
+  .union([
+    z.lazy(() => Error2$inboundSchema),
+    z.lazy(() => Error3$inboundSchema),
+    z.lazy(() => Error1$inboundSchema),
+    z.lazy(() => Error4$inboundSchema),
+  ]);
 
 /** @internal */
-export type GetOrderError$Outbound =
+export type ErrorT$Outbound =
   | Error2$Outbound
   | Error3$Outbound
   | Error1$Outbound
   | Error4$Outbound;
 
 /** @internal */
-export const GetOrderError$outboundSchema: z.ZodType<
-  GetOrderError$Outbound,
+export const ErrorT$outboundSchema: z.ZodType<
+  ErrorT$Outbound,
   z.ZodTypeDef,
-  GetOrderError
+  ErrorT
 > = z.union([
   z.lazy(() => Error2$outboundSchema),
   z.lazy(() => Error3$outboundSchema),
@@ -1184,26 +1165,26 @@ export const GetOrderError$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace GetOrderError$ {
-  /** @deprecated use `GetOrderError$inboundSchema` instead. */
-  export const inboundSchema = GetOrderError$inboundSchema;
-  /** @deprecated use `GetOrderError$outboundSchema` instead. */
-  export const outboundSchema = GetOrderError$outboundSchema;
-  /** @deprecated use `GetOrderError$Outbound` instead. */
-  export type Outbound = GetOrderError$Outbound;
+export namespace ErrorT$ {
+  /** @deprecated use `ErrorT$inboundSchema` instead. */
+  export const inboundSchema = ErrorT$inboundSchema;
+  /** @deprecated use `ErrorT$outboundSchema` instead. */
+  export const outboundSchema = ErrorT$outboundSchema;
+  /** @deprecated use `ErrorT$Outbound` instead. */
+  export type Outbound = ErrorT$Outbound;
 }
 
-export function getOrderErrorToJSON(getOrderError: GetOrderError): string {
-  return JSON.stringify(GetOrderError$outboundSchema.parse(getOrderError));
+export function errorToJSON(errorT: ErrorT): string {
+  return JSON.stringify(ErrorT$outboundSchema.parse(errorT));
 }
 
-export function getOrderErrorFromJSON(
+export function errorFromJSON(
   jsonString: string,
-): SafeParseResult<GetOrderError, SDKValidationError> {
+): SafeParseResult<ErrorT, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => GetOrderError$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GetOrderError' from JSON`,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
   );
 }
 

package/src/models/getprojectenvop.ts

@@ -42,10 +42,10 @@ export type GetProjectEnvResponseBodyProjectsResponseTarget =
 
 export const GetProjectEnvResponseBodyProjectsResponseType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type GetProjectEnvResponseBodyProjectsResponseType = ClosedEnum<
   typeof GetProjectEnvResponseBodyProjectsResponseType
@@ -388,10 +388,10 @@ export type GetProjectEnvResponseBodyProjectsTarget =
 
 export const GetProjectEnvResponseBodyProjectsType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type GetProjectEnvResponseBodyProjectsType = ClosedEnum<
   typeof GetProjectEnvResponseBodyProjectsType
@@ -732,10 +732,10 @@ export type GetProjectEnvResponseBodyTarget =
 
 export const GetProjectEnvResponseBodyType = {
   System: "system",
-  Secret: "secret",
   Encrypted: "encrypted",
   Plain: "plain",
   Sensitive: "sensitive",
+  Secret: "secret",
 } as const;
 export type GetProjectEnvResponseBodyType = ClosedEnum<
   typeof GetProjectEnvResponseBodyType

package/src/models/getprojectsop.ts

@@ -704,6 +704,7 @@ export const GetProjectsFramework = {
   Hono: "hono",
   Express: "express",
   H3: "h3",
+  Nestjs: "nestjs",
   Xmcp: "xmcp",
 } as const;
 export type GetProjectsFramework = ClosedEnum<typeof GetProjectsFramework>;

package/src/models/gettldpriceop.ts

@@ -6,24 +6,18 @@ import * as z from "zod";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import {
-  InternalServerError,
-  InternalServerError$inboundSchema,
-  InternalServerError$Outbound,
-  InternalServerError$outboundSchema,
-} from "./internalservererror.js";
-import {
-  NotAuthorizedForScope,
-  NotAuthorizedForScope$inboundSchema,
-  NotAuthorizedForScope$Outbound,
-  NotAuthorizedForScope$outboundSchema,
-} from "./notauthorizedforscope.js";
+  HttpApiDecodeError,
+  HttpApiDecodeError$inboundSchema,
+  HttpApiDecodeError$Outbound,
+  HttpApiDecodeError$outboundSchema,
+} from "./httpapidecodeerror.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 GetTldPriceRequest = {
   tld: string;
@@ -31,28 +25,30 @@ export type GetTldPriceRequest = {
 };
 
 /**
- * Unauthorized
+ * There was something wrong with the request
  */
 export type GetTldPriceDomainsRegistrarResponseBody =
-  | Unauthorized
-  | NotAuthorizedForScope
-  | InternalServerError;
+  | TldNotSupported
+  | HttpApiDecodeError;
 
 /**
  * Success
  */
 export type GetTldPriceResponseBody = {
+  /**
+   * The number of years the returned price is for.
+   */
   years: number;
   /**
-   * Represents a monetary amount in USD dollars
+   * The base TLD price for purchasing a domain for the given number of years. If null, the TLD does not support purchasing domains for the given number of years.
    */
   purchasePrice: number;
   /**
-   * Represents a monetary amount in USD dollars
+   * The base TLD price for purchasing a domain for the given number of years. If null, the TLD does not support purchasing domains for the given number of years.
    */
   renewalPrice: number;
   /**
-   * Represents a monetary amount in USD dollars
+   * The base TLD price for purchasing a domain for the given number of years. If null, the TLD does not support purchasing domains for the given number of years.
    */
   transferPrice: number;
 };
@@ -119,17 +115,12 @@ export const GetTldPriceDomainsRegistrarResponseBody$inboundSchema: z.ZodType<
   GetTldPriceDomainsRegistrarResponseBody,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  Unauthorized$inboundSchema,
-  NotAuthorizedForScope$inboundSchema,
-  InternalServerError$inboundSchema,
-]);
+> = z.union([TldNotSupported$inboundSchema, HttpApiDecodeError$inboundSchema]);
 
 /** @internal */
 export type GetTldPriceDomainsRegistrarResponseBody$Outbound =
-  | Unauthorized$Outbound
-  | NotAuthorizedForScope$Outbound
-  | InternalServerError$Outbound;
+  | TldNotSupported$Outbound
+  | HttpApiDecodeError$Outbound;
 
 /** @internal */
 export const GetTldPriceDomainsRegistrarResponseBody$outboundSchema: z.ZodType<
@@ -137,9 +128,8 @@ export const GetTldPriceDomainsRegistrarResponseBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   GetTldPriceDomainsRegistrarResponseBody
 > = z.union([
-  Unauthorized$outboundSchema,
-  NotAuthorizedForScope$outboundSchema,
-  InternalServerError$outboundSchema,
+  TldNotSupported$outboundSchema,
+  HttpApiDecodeError$outboundSchema,
 ]);
 
 /**

package/src/models/httpapidecodeerror.ts

@@ -0,0 +1,93 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import {
+  Issue,
+  Issue$inboundSchema,
+  Issue$Outbound,
+  Issue$outboundSchema,
+} from "./issue.js";
+import { VercelError } from "./vercelerror.js";
+
+/**
+ * The request did not match the expected schema
+ */
+export type HttpApiDecodeErrorData = {
+  issues: Array<Issue>;
+  message: string;
+};
+
+/**
+ * The request did not match the expected schema
+ */
+export class HttpApiDecodeError extends VercelError {
+  issues: Array<Issue>;
+
+  /** The original data that was passed to this error instance. */
+  data$: HttpApiDecodeErrorData;
+
+  constructor(
+    err: HttpApiDecodeErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.issues = err.issues;
+
+    this.name = "HttpApiDecodeError";
+  }
+}
+
+/** @internal */
+export const HttpApiDecodeError$inboundSchema: z.ZodType<
+  HttpApiDecodeError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  issues: z.array(Issue$inboundSchema),
+  message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new HttpApiDecodeError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type HttpApiDecodeError$Outbound = {
+  issues: Array<Issue$Outbound>;
+  message: string;
+};
+
+/** @internal */
+export const HttpApiDecodeError$outboundSchema: z.ZodType<
+  HttpApiDecodeError$Outbound,
+  z.ZodTypeDef,
+  HttpApiDecodeError
+> = z.instanceof(HttpApiDecodeError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    issues: z.array(Issue$outboundSchema),
+    message: z.string(),
+  }));
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace HttpApiDecodeError$ {
+  /** @deprecated use `HttpApiDecodeError$inboundSchema` instead. */
+  export const inboundSchema = HttpApiDecodeError$inboundSchema;
+  /** @deprecated use `HttpApiDecodeError$outboundSchema` instead. */
+  export const outboundSchema = HttpApiDecodeError$outboundSchema;
+  /** @deprecated use `HttpApiDecodeError$Outbound` instead. */
+  export type Outbound = HttpApiDecodeError$Outbound;
+}

package/src/models/internalservererror.ts

@@ -3,7 +3,6 @@
  */
 
 import * as z from "zod";
-import { remap as remap$ } from "../lib/primitives.js";
 import { ClosedEnum } from "../types/enums.js";
 import { VercelError } from "./vercelerror.js";
 
@@ -14,22 +13,15 @@ export type InternalServerErrorCode = ClosedEnum<
   typeof InternalServerErrorCode
 >;
 
-export const InternalServerErrorTag = {
-  InternalServerError: "InternalServerError",
-} as const;
-export type InternalServerErrorTag = ClosedEnum<typeof InternalServerErrorTag>;
-
 export type InternalServerErrorData = {
   status: number;
   code: InternalServerErrorCode;
   message: string;
-  tag: InternalServerErrorTag;
 };
 
 export class InternalServerError extends VercelError {
   status: number;
   code: InternalServerErrorCode;
-  tag: InternalServerErrorTag;
 
   /** The original data that was passed to this error instance. */
   data$: InternalServerErrorData;
@@ -43,7 +35,6 @@ export class InternalServerError extends VercelError {
     this.data$ = err;
     this.status = err.status;
     this.code = err.code;
-    this.tag = err.tag;
 
     this.name = "InternalServerError";
   }
@@ -70,27 +61,6 @@ export namespace InternalServerErrorCode$ {
   export const outboundSchema = InternalServerErrorCode$outboundSchema;
 }
 
-/** @internal */
-export const InternalServerErrorTag$inboundSchema: z.ZodNativeEnum<
-  typeof InternalServerErrorTag
-> = z.nativeEnum(InternalServerErrorTag);
-
-/** @internal */
-export const InternalServerErrorTag$outboundSchema: z.ZodNativeEnum<
-  typeof InternalServerErrorTag
-> = InternalServerErrorTag$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace InternalServerErrorTag$ {
-  /** @deprecated use `InternalServerErrorTag$inboundSchema` instead. */
-  export const inboundSchema = InternalServerErrorTag$inboundSchema;
-  /** @deprecated use `InternalServerErrorTag$outboundSchema` instead. */
-  export const outboundSchema = InternalServerErrorTag$outboundSchema;
-}
-
 /** @internal */
 export const InternalServerError$inboundSchema: z.ZodType<
   InternalServerError,
@@ -100,17 +70,12 @@ export const InternalServerError$inboundSchema: z.ZodType<
   status: z.number(),
   code: InternalServerErrorCode$inboundSchema,
   message: z.string(),
-  _tag: InternalServerErrorTag$inboundSchema,
   request$: z.instanceof(Request),
   response$: z.instanceof(Response),
   body$: z.string(),
 })
   .transform((v) => {
-    const remapped = remap$(v, {
-      "_tag": "tag",
-    });
-
-    return new InternalServerError(remapped, {
+    return new InternalServerError(v, {
       request: v.request$,
       response: v.response$,
       body: v.body$,
@@ -122,7 +87,6 @@ export type InternalServerError$Outbound = {
   status: number;
   code: string;
   message: string;
-  _tag: string;
 };
 
 /** @internal */
@@ -132,18 +96,11 @@ export const InternalServerError$outboundSchema: z.ZodType<
   InternalServerError
 > = z.instanceof(InternalServerError)
   .transform(v => v.data$)
-  .pipe(
-    z.object({
-      status: z.number(),
-      code: InternalServerErrorCode$outboundSchema,
-      message: z.string(),
-      tag: InternalServerErrorTag$outboundSchema,
-    }).transform((v) => {
-      return remap$(v, {
-        tag: "_tag",
-      });
-    }),
-  );
+  .pipe(z.object({
+    status: z.number(),
+    code: InternalServerErrorCode$outboundSchema,
+    message: z.string(),
+  }));
 
 /**
  * @internal

package/src/models/invalidadditionalcontactinfo.ts

@@ -0,0 +1,122 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+import { VercelError } from "./vercelerror.js";
+
+export const InvalidAdditionalContactInfoCode = {
+  InvalidAdditionalContactInfo: "invalid_additional_contact_info",
+} as const;
+export type InvalidAdditionalContactInfoCode = ClosedEnum<
+  typeof InvalidAdditionalContactInfoCode
+>;
+
+/**
+ * Additional contact information provided for the TLD is invalid.
+ */
+export type InvalidAdditionalContactInfoData = {
+  status: number;
+  code: InvalidAdditionalContactInfoCode;
+  message: string;
+};
+
+/**
+ * Additional contact information provided for the TLD is invalid.
+ */
+export class InvalidAdditionalContactInfo extends VercelError {
+  status: number;
+  code: InvalidAdditionalContactInfoCode;
+
+  /** The original data that was passed to this error instance. */
+  data$: InvalidAdditionalContactInfoData;
+
+  constructor(
+    err: InvalidAdditionalContactInfoData,
+    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.name = "InvalidAdditionalContactInfo";
+  }
+}
+
+/** @internal */
+export const InvalidAdditionalContactInfoCode$inboundSchema: z.ZodNativeEnum<
+  typeof InvalidAdditionalContactInfoCode
+> = z.nativeEnum(InvalidAdditionalContactInfoCode);
+
+/** @internal */
+export const InvalidAdditionalContactInfoCode$outboundSchema: z.ZodNativeEnum<
+  typeof InvalidAdditionalContactInfoCode
+> = InvalidAdditionalContactInfoCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InvalidAdditionalContactInfoCode$ {
+  /** @deprecated use `InvalidAdditionalContactInfoCode$inboundSchema` instead. */
+  export const inboundSchema = InvalidAdditionalContactInfoCode$inboundSchema;
+  /** @deprecated use `InvalidAdditionalContactInfoCode$outboundSchema` instead. */
+  export const outboundSchema = InvalidAdditionalContactInfoCode$outboundSchema;
+}
+
+/** @internal */
+export const InvalidAdditionalContactInfo$inboundSchema: z.ZodType<
+  InvalidAdditionalContactInfo,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  status: z.number(),
+  code: InvalidAdditionalContactInfoCode$inboundSchema,
+  message: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new InvalidAdditionalContactInfo(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type InvalidAdditionalContactInfo$Outbound = {
+  status: number;
+  code: string;
+  message: string;
+};
+
+/** @internal */
+export const InvalidAdditionalContactInfo$outboundSchema: z.ZodType<
+  InvalidAdditionalContactInfo$Outbound,
+  z.ZodTypeDef,
+  InvalidAdditionalContactInfo
+> = z.instanceof(InvalidAdditionalContactInfo)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    status: z.number(),
+    code: InvalidAdditionalContactInfoCode$outboundSchema,
+    message: z.string(),
+  }));
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InvalidAdditionalContactInfo$ {
+  /** @deprecated use `InvalidAdditionalContactInfo$inboundSchema` instead. */
+  export const inboundSchema = InvalidAdditionalContactInfo$inboundSchema;
+  /** @deprecated use `InvalidAdditionalContactInfo$outboundSchema` instead. */
+  export const outboundSchema = InvalidAdditionalContactInfo$outboundSchema;
+  /** @deprecated use `InvalidAdditionalContactInfo$Outbound` instead. */
+  export type Outbound = InvalidAdditionalContactInfo$Outbound;
+}