@vercel/sdk 1.18.3 → 1.18.5

package/src/models/{putv1bulkredirectsop.ts → stageredirectsop.ts}

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
@@ -18,7 +19,7 @@ export type Redirects = {
   query?: boolean | undefined;
 };
 
-export type PutV1BulkRedirectsRequestBody = {
+export type StageRedirectsRequestBody = {
   projectId: string;
   teamId: string;
   overwrite?: boolean | undefined;
@@ -26,7 +27,19 @@ export type PutV1BulkRedirectsRequestBody = {
   redirects?: Array<Redirects> | undefined;
 };
 
-export type PutV1BulkRedirectsVersion = {
+export type StageRedirectsRequest = {
+  /**
+   * The Team identifier to perform the request on behalf of.
+   */
+  teamId?: string | undefined;
+  /**
+   * The Team slug to perform the request on behalf of.
+   */
+  slug?: string | undefined;
+  requestBody?: StageRedirectsRequestBody | undefined;
+};
+
+export type StageRedirectsVersion = {
   /**
    * The unique identifier for the version.
    */
@@ -59,9 +72,9 @@ export type PutV1BulkRedirectsVersion = {
   alias?: string | undefined;
 };
 
-export type PutV1BulkRedirectsResponseBody = {
+export type StageRedirectsResponseBody = {
   alias: string | null;
-  version: PutV1BulkRedirectsVersion;
+  version: StageRedirectsVersion;
 };
 
 /** @internal */
@@ -144,8 +157,8 @@ export function redirectsFromJSON(
 }
 
 /** @internal */
-export const PutV1BulkRedirectsRequestBody$inboundSchema: z.ZodType<
-  PutV1BulkRedirectsRequestBody,
+export const StageRedirectsRequestBody$inboundSchema: z.ZodType<
+  StageRedirectsRequestBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -156,7 +169,7 @@ export const PutV1BulkRedirectsRequestBody$inboundSchema: z.ZodType<
   redirects: z.array(z.lazy(() => Redirects$inboundSchema)).optional(),
 });
 /** @internal */
-export type PutV1BulkRedirectsRequestBody$Outbound = {
+export type StageRedirectsRequestBody$Outbound = {
   projectId: string;
   teamId: string;
   overwrite?: boolean | undefined;
@@ -165,10 +178,10 @@ export type PutV1BulkRedirectsRequestBody$Outbound = {
 };
 
 /** @internal */
-export const PutV1BulkRedirectsRequestBody$outboundSchema: z.ZodType<
-  PutV1BulkRedirectsRequestBody$Outbound,
+export const StageRedirectsRequestBody$outboundSchema: z.ZodType<
+  StageRedirectsRequestBody$Outbound,
   z.ZodTypeDef,
-  PutV1BulkRedirectsRequestBody
+  StageRedirectsRequestBody
 > = z.object({
   projectId: z.string(),
   teamId: z.string(),
@@ -177,28 +190,80 @@ export const PutV1BulkRedirectsRequestBody$outboundSchema: z.ZodType<
   redirects: z.array(z.lazy(() => Redirects$outboundSchema)).optional(),
 });
 
-export function putV1BulkRedirectsRequestBodyToJSON(
-  putV1BulkRedirectsRequestBody: PutV1BulkRedirectsRequestBody,
+export function stageRedirectsRequestBodyToJSON(
+  stageRedirectsRequestBody: StageRedirectsRequestBody,
+): string {
+  return JSON.stringify(
+    StageRedirectsRequestBody$outboundSchema.parse(stageRedirectsRequestBody),
+  );
+}
+export function stageRedirectsRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<StageRedirectsRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StageRedirectsRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StageRedirectsRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const StageRedirectsRequest$inboundSchema: z.ZodType<
+  StageRedirectsRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  teamId: z.string().optional(),
+  slug: z.string().optional(),
+  RequestBody: z.lazy(() => StageRedirectsRequestBody$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type StageRedirectsRequest$Outbound = {
+  teamId?: string | undefined;
+  slug?: string | undefined;
+  RequestBody?: StageRedirectsRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const StageRedirectsRequest$outboundSchema: z.ZodType<
+  StageRedirectsRequest$Outbound,
+  z.ZodTypeDef,
+  StageRedirectsRequest
+> = z.object({
+  teamId: z.string().optional(),
+  slug: z.string().optional(),
+  requestBody: z.lazy(() => StageRedirectsRequestBody$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function stageRedirectsRequestToJSON(
+  stageRedirectsRequest: StageRedirectsRequest,
 ): string {
   return JSON.stringify(
-    PutV1BulkRedirectsRequestBody$outboundSchema.parse(
-      putV1BulkRedirectsRequestBody,
-    ),
+    StageRedirectsRequest$outboundSchema.parse(stageRedirectsRequest),
   );
 }
-export function putV1BulkRedirectsRequestBodyFromJSON(
+export function stageRedirectsRequestFromJSON(
   jsonString: string,
-): SafeParseResult<PutV1BulkRedirectsRequestBody, SDKValidationError> {
+): SafeParseResult<StageRedirectsRequest, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PutV1BulkRedirectsRequestBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PutV1BulkRedirectsRequestBody' from JSON`,
+    (x) => StageRedirectsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StageRedirectsRequest' from JSON`,
   );
 }
 
 /** @internal */
-export const PutV1BulkRedirectsVersion$inboundSchema: z.ZodType<
-  PutV1BulkRedirectsVersion,
+export const StageRedirectsVersion$inboundSchema: z.ZodType<
+  StageRedirectsVersion,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -213,7 +278,7 @@ export const PutV1BulkRedirectsVersion$inboundSchema: z.ZodType<
   alias: z.string().optional(),
 });
 /** @internal */
-export type PutV1BulkRedirectsVersion$Outbound = {
+export type StageRedirectsVersion$Outbound = {
   id: string;
   key: string;
   lastModified: number;
@@ -226,10 +291,10 @@ export type PutV1BulkRedirectsVersion$Outbound = {
 };
 
 /** @internal */
-export const PutV1BulkRedirectsVersion$outboundSchema: z.ZodType<
-  PutV1BulkRedirectsVersion$Outbound,
+export const StageRedirectsVersion$outboundSchema: z.ZodType<
+  StageRedirectsVersion$Outbound,
   z.ZodTypeDef,
-  PutV1BulkRedirectsVersion
+  StageRedirectsVersion
 > = z.object({
   id: z.string(),
   key: z.string(),
@@ -242,63 +307,61 @@ export const PutV1BulkRedirectsVersion$outboundSchema: z.ZodType<
   alias: z.string().optional(),
 });
 
-export function putV1BulkRedirectsVersionToJSON(
-  putV1BulkRedirectsVersion: PutV1BulkRedirectsVersion,
+export function stageRedirectsVersionToJSON(
+  stageRedirectsVersion: StageRedirectsVersion,
 ): string {
   return JSON.stringify(
-    PutV1BulkRedirectsVersion$outboundSchema.parse(putV1BulkRedirectsVersion),
+    StageRedirectsVersion$outboundSchema.parse(stageRedirectsVersion),
   );
 }
-export function putV1BulkRedirectsVersionFromJSON(
+export function stageRedirectsVersionFromJSON(
   jsonString: string,
-): SafeParseResult<PutV1BulkRedirectsVersion, SDKValidationError> {
+): SafeParseResult<StageRedirectsVersion, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PutV1BulkRedirectsVersion$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PutV1BulkRedirectsVersion' from JSON`,
+    (x) => StageRedirectsVersion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StageRedirectsVersion' from JSON`,
   );
 }
 
 /** @internal */
-export const PutV1BulkRedirectsResponseBody$inboundSchema: z.ZodType<
-  PutV1BulkRedirectsResponseBody,
+export const StageRedirectsResponseBody$inboundSchema: z.ZodType<
+  StageRedirectsResponseBody,
   z.ZodTypeDef,
   unknown
 > = z.object({
   alias: z.nullable(z.string()),
-  version: z.lazy(() => PutV1BulkRedirectsVersion$inboundSchema),
+  version: z.lazy(() => StageRedirectsVersion$inboundSchema),
 });
 /** @internal */
-export type PutV1BulkRedirectsResponseBody$Outbound = {
+export type StageRedirectsResponseBody$Outbound = {
   alias: string | null;
-  version: PutV1BulkRedirectsVersion$Outbound;
+  version: StageRedirectsVersion$Outbound;
 };
 
 /** @internal */
-export const PutV1BulkRedirectsResponseBody$outboundSchema: z.ZodType<
-  PutV1BulkRedirectsResponseBody$Outbound,
+export const StageRedirectsResponseBody$outboundSchema: z.ZodType<
+  StageRedirectsResponseBody$Outbound,
   z.ZodTypeDef,
-  PutV1BulkRedirectsResponseBody
+  StageRedirectsResponseBody
 > = z.object({
   alias: z.nullable(z.string()),
-  version: z.lazy(() => PutV1BulkRedirectsVersion$outboundSchema),
+  version: z.lazy(() => StageRedirectsVersion$outboundSchema),
 });
 
-export function putV1BulkRedirectsResponseBodyToJSON(
-  putV1BulkRedirectsResponseBody: PutV1BulkRedirectsResponseBody,
+export function stageRedirectsResponseBodyToJSON(
+  stageRedirectsResponseBody: StageRedirectsResponseBody,
 ): string {
   return JSON.stringify(
-    PutV1BulkRedirectsResponseBody$outboundSchema.parse(
-      putV1BulkRedirectsResponseBody,
-    ),
+    StageRedirectsResponseBody$outboundSchema.parse(stageRedirectsResponseBody),
   );
 }
-export function putV1BulkRedirectsResponseBodyFromJSON(
+export function stageRedirectsResponseBodyFromJSON(
   jsonString: string,
-): SafeParseResult<PutV1BulkRedirectsResponseBody, SDKValidationError> {
+): SafeParseResult<StageRedirectsResponseBody, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => PutV1BulkRedirectsResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'PutV1BulkRedirectsResponseBody' from JSON`,
+    (x) => StageRedirectsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StageRedirectsResponseBody' from JSON`,
   );
 }

package/src/models/team.ts

@@ -219,11 +219,11 @@ export type SsoProtection = {
 };
 
 /**
- * Default deployment protection for this team
+ * Default deployment protection for this team null indicates protection is disabled
  */
 export type DefaultDeploymentProtection = {
-  passwordProtection?: PasswordProtection | undefined;
-  ssoProtection?: SsoProtection | undefined;
+  passwordProtection?: PasswordProtection | null | undefined;
+  ssoProtection?: SsoProtection | null | undefined;
 };
 
 /**
@@ -451,7 +451,7 @@ export type Team = {
    */
   remoteCaching?: RemoteCaching | undefined;
   /**
-   * Default deployment protection for this team
+   * Default deployment protection for this team null indicates protection is disabled
    */
   defaultDeploymentProtection?: DefaultDeploymentProtection | undefined;
   /**
@@ -1056,13 +1056,15 @@ export const DefaultDeploymentProtection$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  passwordProtection: z.lazy(() => PasswordProtection$inboundSchema).optional(),
-  ssoProtection: z.lazy(() => SsoProtection$inboundSchema).optional(),
+  passwordProtection: z.nullable(z.lazy(() => PasswordProtection$inboundSchema))
+    .optional(),
+  ssoProtection: z.nullable(z.lazy(() => SsoProtection$inboundSchema))
+    .optional(),
 });
 /** @internal */
 export type DefaultDeploymentProtection$Outbound = {
-  passwordProtection?: PasswordProtection$Outbound | undefined;
-  ssoProtection?: SsoProtection$Outbound | undefined;
+  passwordProtection?: PasswordProtection$Outbound | null | undefined;
+  ssoProtection?: SsoProtection$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -1071,9 +1073,11 @@ export const DefaultDeploymentProtection$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   DefaultDeploymentProtection
 > = z.object({
-  passwordProtection: z.lazy(() => PasswordProtection$outboundSchema)
+  passwordProtection: z.nullable(
+    z.lazy(() => PasswordProtection$outboundSchema),
+  ).optional(),
+  ssoProtection: z.nullable(z.lazy(() => SsoProtection$outboundSchema))
     .optional(),
-  ssoProtection: z.lazy(() => SsoProtection$outboundSchema).optional(),
 });
 
 export function defaultDeploymentProtectionToJSON(

package/src/models/updateversionop.ts

@@ -0,0 +1,285 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
+
+export const UpdateVersionAction = {
+  Promote: "promote",
+  Restore: "restore",
+  Discard: "discard",
+} as const;
+export type UpdateVersionAction = ClosedEnum<typeof UpdateVersionAction>;
+
+export type UpdateVersionRequestBody = {
+  id: string;
+  action: UpdateVersionAction;
+  name?: string | undefined;
+};
+
+export type UpdateVersionRequest = {
+  projectId: string;
+  /**
+   * The Team identifier to perform the request on behalf of.
+   */
+  teamId?: string | undefined;
+  /**
+   * The Team slug to perform the request on behalf of.
+   */
+  slug?: string | undefined;
+  requestBody?: UpdateVersionRequestBody | undefined;
+};
+
+export type UpdateVersionVersion = {
+  /**
+   * The unique identifier for the version.
+   */
+  id: string;
+  /**
+   * The key of the version. The key may be duplicated across versions if the contents are the same as a different version.
+   */
+  key: string;
+  lastModified: number;
+  createdBy: string;
+  /**
+   * Optional name for the version. If not provided, defaults to an ISO timestamp string.
+   */
+  name?: string | undefined;
+  /**
+   * Whether this version has not been promoted to production yet and is not serving end users.
+   */
+  isStaging?: boolean | undefined;
+  /**
+   * Whether this version is currently live in production.
+   */
+  isLive?: boolean | undefined;
+  /**
+   * The number of redirects in this version.
+   */
+  redirectCount?: number | undefined;
+  /**
+   * The staging link for previewing redirects in this version.
+   */
+  alias?: string | undefined;
+};
+
+export type UpdateVersionResponseBody = {
+  version: UpdateVersionVersion;
+};
+
+/** @internal */
+export const UpdateVersionAction$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateVersionAction
+> = z.nativeEnum(UpdateVersionAction);
+/** @internal */
+export const UpdateVersionAction$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateVersionAction
+> = UpdateVersionAction$inboundSchema;
+
+/** @internal */
+export const UpdateVersionRequestBody$inboundSchema: z.ZodType<
+  UpdateVersionRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  action: UpdateVersionAction$inboundSchema,
+  name: z.string().optional(),
+});
+/** @internal */
+export type UpdateVersionRequestBody$Outbound = {
+  id: string;
+  action: string;
+  name?: string | undefined;
+};
+
+/** @internal */
+export const UpdateVersionRequestBody$outboundSchema: z.ZodType<
+  UpdateVersionRequestBody$Outbound,
+  z.ZodTypeDef,
+  UpdateVersionRequestBody
+> = z.object({
+  id: z.string(),
+  action: UpdateVersionAction$outboundSchema,
+  name: z.string().optional(),
+});
+
+export function updateVersionRequestBodyToJSON(
+  updateVersionRequestBody: UpdateVersionRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateVersionRequestBody$outboundSchema.parse(updateVersionRequestBody),
+  );
+}
+export function updateVersionRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVersionRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVersionRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVersionRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVersionRequest$inboundSchema: z.ZodType<
+  UpdateVersionRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  projectId: z.string(),
+  teamId: z.string().optional(),
+  slug: z.string().optional(),
+  RequestBody: z.lazy(() => UpdateVersionRequestBody$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type UpdateVersionRequest$Outbound = {
+  projectId: string;
+  teamId?: string | undefined;
+  slug?: string | undefined;
+  RequestBody?: UpdateVersionRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const UpdateVersionRequest$outboundSchema: z.ZodType<
+  UpdateVersionRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateVersionRequest
+> = z.object({
+  projectId: z.string(),
+  teamId: z.string().optional(),
+  slug: z.string().optional(),
+  requestBody: z.lazy(() => UpdateVersionRequestBody$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function updateVersionRequestToJSON(
+  updateVersionRequest: UpdateVersionRequest,
+): string {
+  return JSON.stringify(
+    UpdateVersionRequest$outboundSchema.parse(updateVersionRequest),
+  );
+}
+export function updateVersionRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVersionRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVersionRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVersionRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVersionVersion$inboundSchema: z.ZodType<
+  UpdateVersionVersion,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  key: z.string(),
+  lastModified: z.number(),
+  createdBy: z.string(),
+  name: z.string().optional(),
+  isStaging: z.boolean().optional(),
+  isLive: z.boolean().optional(),
+  redirectCount: z.number().optional(),
+  alias: z.string().optional(),
+});
+/** @internal */
+export type UpdateVersionVersion$Outbound = {
+  id: string;
+  key: string;
+  lastModified: number;
+  createdBy: string;
+  name?: string | undefined;
+  isStaging?: boolean | undefined;
+  isLive?: boolean | undefined;
+  redirectCount?: number | undefined;
+  alias?: string | undefined;
+};
+
+/** @internal */
+export const UpdateVersionVersion$outboundSchema: z.ZodType<
+  UpdateVersionVersion$Outbound,
+  z.ZodTypeDef,
+  UpdateVersionVersion
+> = z.object({
+  id: z.string(),
+  key: z.string(),
+  lastModified: z.number(),
+  createdBy: z.string(),
+  name: z.string().optional(),
+  isStaging: z.boolean().optional(),
+  isLive: z.boolean().optional(),
+  redirectCount: z.number().optional(),
+  alias: z.string().optional(),
+});
+
+export function updateVersionVersionToJSON(
+  updateVersionVersion: UpdateVersionVersion,
+): string {
+  return JSON.stringify(
+    UpdateVersionVersion$outboundSchema.parse(updateVersionVersion),
+  );
+}
+export function updateVersionVersionFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVersionVersion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVersionVersion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVersionVersion' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateVersionResponseBody$inboundSchema: z.ZodType<
+  UpdateVersionResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  version: z.lazy(() => UpdateVersionVersion$inboundSchema),
+});
+/** @internal */
+export type UpdateVersionResponseBody$Outbound = {
+  version: UpdateVersionVersion$Outbound;
+};
+
+/** @internal */
+export const UpdateVersionResponseBody$outboundSchema: z.ZodType<
+  UpdateVersionResponseBody$Outbound,
+  z.ZodTypeDef,
+  UpdateVersionResponseBody
+> = z.object({
+  version: z.lazy(() => UpdateVersionVersion$outboundSchema),
+});
+
+export function updateVersionResponseBodyToJSON(
+  updateVersionResponseBody: UpdateVersionResponseBody,
+): string {
+  return JSON.stringify(
+    UpdateVersionResponseBody$outboundSchema.parse(updateVersionResponseBody),
+  );
+}
+export function updateVersionResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateVersionResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateVersionResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateVersionResponseBody' from JSON`,
+  );
+}