@vercel/sdk 1.18.3 → 1.18.5

package/src/models/listaccessgroupsop.ts

@@ -82,14 +82,14 @@ export type AccessGroups = {
   teamRoles?: Array<string> | undefined;
 };
 
-export type ListAccessGroupsResponseBodyPagination = {
+export type ResponseBodyPagination = {
   count: number;
   next: string | null;
 };
 
 export type ListAccessGroupsResponseBody2 = {
   accessGroups: Array<AccessGroups>;
-  pagination: ListAccessGroupsResponseBodyPagination;
+  pagination: ResponseBodyPagination;
 };
 
 export type ListAccessGroupsResponseBody1 = {};
@@ -230,8 +230,8 @@ export function accessGroupsFromJSON(
 }
 
 /** @internal */
-export const ListAccessGroupsResponseBodyPagination$inboundSchema: z.ZodType<
-  ListAccessGroupsResponseBodyPagination,
+export const ResponseBodyPagination$inboundSchema: z.ZodType<
+  ResponseBodyPagination,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -239,39 +239,35 @@ export const ListAccessGroupsResponseBodyPagination$inboundSchema: z.ZodType<
   next: z.nullable(z.string()),
 });
 /** @internal */
-export type ListAccessGroupsResponseBodyPagination$Outbound = {
+export type ResponseBodyPagination$Outbound = {
   count: number;
   next: string | null;
 };
 
 /** @internal */
-export const ListAccessGroupsResponseBodyPagination$outboundSchema: z.ZodType<
-  ListAccessGroupsResponseBodyPagination$Outbound,
+export const ResponseBodyPagination$outboundSchema: z.ZodType<
+  ResponseBodyPagination$Outbound,
   z.ZodTypeDef,
-  ListAccessGroupsResponseBodyPagination
+  ResponseBodyPagination
 > = z.object({
   count: z.number(),
   next: z.nullable(z.string()),
 });
 
-export function listAccessGroupsResponseBodyPaginationToJSON(
-  listAccessGroupsResponseBodyPagination:
-    ListAccessGroupsResponseBodyPagination,
+export function responseBodyPaginationToJSON(
+  responseBodyPagination: ResponseBodyPagination,
 ): string {
   return JSON.stringify(
-    ListAccessGroupsResponseBodyPagination$outboundSchema.parse(
-      listAccessGroupsResponseBodyPagination,
-    ),
+    ResponseBodyPagination$outboundSchema.parse(responseBodyPagination),
   );
 }
-export function listAccessGroupsResponseBodyPaginationFromJSON(
+export function responseBodyPaginationFromJSON(
   jsonString: string,
-): SafeParseResult<ListAccessGroupsResponseBodyPagination, SDKValidationError> {
+): SafeParseResult<ResponseBodyPagination, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) =>
-      ListAccessGroupsResponseBodyPagination$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListAccessGroupsResponseBodyPagination' from JSON`,
+    (x) => ResponseBodyPagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyPagination' from JSON`,
   );
 }
 
@@ -282,14 +278,12 @@ export const ListAccessGroupsResponseBody2$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   accessGroups: z.array(z.lazy(() => AccessGroups$inboundSchema)),
-  pagination: z.lazy(() =>
-    ListAccessGroupsResponseBodyPagination$inboundSchema
-  ),
+  pagination: z.lazy(() => ResponseBodyPagination$inboundSchema),
 });
 /** @internal */
 export type ListAccessGroupsResponseBody2$Outbound = {
   accessGroups: Array<AccessGroups$Outbound>;
-  pagination: ListAccessGroupsResponseBodyPagination$Outbound;
+  pagination: ResponseBodyPagination$Outbound;
 };
 
 /** @internal */
@@ -299,9 +293,7 @@ export const ListAccessGroupsResponseBody2$outboundSchema: z.ZodType<
   ListAccessGroupsResponseBody2
 > = z.object({
   accessGroups: z.array(z.lazy(() => AccessGroups$outboundSchema)),
-  pagination: z.lazy(() =>
-    ListAccessGroupsResponseBodyPagination$outboundSchema
-  ),
+  pagination: z.lazy(() => ResponseBodyPagination$outboundSchema),
 });
 
 export function listAccessGroupsResponseBody2ToJSON(

package/src/models/putfirewallconfigop.ts

@@ -9,6 +9,8 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
 
+export type ManagedRules = {};
+
 export const PutFirewallConfigAction = {
   Deny: "deny",
   Log: "log",
@@ -391,7 +393,7 @@ export type Ips = {
 
 export type PutFirewallConfigRequestBody = {
   firewallEnabled: boolean;
-  managedRules?: { [k: string]: any } | undefined;
+  managedRules?: ManagedRules | undefined;
   /**
    * Custom Ruleset
    */
@@ -1056,6 +1058,35 @@ export type PutFirewallConfigResponseBody = {
   active: Active;
 };
 
+/** @internal */
+export const ManagedRules$inboundSchema: z.ZodType<
+  ManagedRules,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type ManagedRules$Outbound = {};
+
+/** @internal */
+export const ManagedRules$outboundSchema: z.ZodType<
+  ManagedRules$Outbound,
+  z.ZodTypeDef,
+  ManagedRules
+> = z.object({});
+
+export function managedRulesToJSON(managedRules: ManagedRules): string {
+  return JSON.stringify(ManagedRules$outboundSchema.parse(managedRules));
+}
+export function managedRulesFromJSON(
+  jsonString: string,
+): SafeParseResult<ManagedRules, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ManagedRules$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ManagedRules' from JSON`,
+  );
+}
+
 /** @internal */
 export const PutFirewallConfigAction$inboundSchema: z.ZodNativeEnum<
   typeof PutFirewallConfigAction
@@ -2176,7 +2207,7 @@ export const PutFirewallConfigRequestBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   firewallEnabled: z.boolean(),
-  managedRules: z.record(z.any()).optional(),
+  managedRules: z.lazy(() => ManagedRules$inboundSchema).optional(),
   crs: z.lazy(() => Crs$inboundSchema).optional(),
   rules: z.array(z.lazy(() => PutFirewallConfigRules$inboundSchema)).optional(),
   ips: z.array(z.lazy(() => Ips$inboundSchema)).optional(),
@@ -2185,7 +2216,7 @@ export const PutFirewallConfigRequestBody$inboundSchema: z.ZodType<
 /** @internal */
 export type PutFirewallConfigRequestBody$Outbound = {
   firewallEnabled: boolean;
-  managedRules?: { [k: string]: any } | undefined;
+  managedRules?: ManagedRules$Outbound | undefined;
   crs?: Crs$Outbound | undefined;
   rules?: Array<PutFirewallConfigRules$Outbound> | undefined;
   ips?: Array<Ips$Outbound> | undefined;
@@ -2199,7 +2230,7 @@ export const PutFirewallConfigRequestBody$outboundSchema: z.ZodType<
   PutFirewallConfigRequestBody
 > = z.object({
   firewallEnabled: z.boolean(),
-  managedRules: z.record(z.any()).optional(),
+  managedRules: z.lazy(() => ManagedRules$outboundSchema).optional(),
   crs: z.lazy(() => Crs$outboundSchema).optional(),
   rules: z.array(z.lazy(() => PutFirewallConfigRules$outboundSchema))
     .optional(),

package/src/models/restoreredirectsop.ts

@@ -0,0 +1,281 @@
+/*
+ * 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 { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
+
+export type RestoreRedirectsRequestBody = {
+  name?: string | undefined;
+  /**
+   * The redirects to restore. The source of the redirect is used to match the redirect to restore.
+   */
+  redirects: Array<string>;
+};
+
+export type RestoreRedirectsRequest = {
+  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?: RestoreRedirectsRequestBody | undefined;
+};
+
+export type RestoreRedirectsVersion = {
+  /**
+   * 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 RestoreRedirectsResponseBody = {
+  version: RestoreRedirectsVersion;
+  restored: Array<string>;
+  failedToRestore: Array<string>;
+};
+
+/** @internal */
+export const RestoreRedirectsRequestBody$inboundSchema: z.ZodType<
+  RestoreRedirectsRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  redirects: z.array(z.string()),
+});
+/** @internal */
+export type RestoreRedirectsRequestBody$Outbound = {
+  name?: string | undefined;
+  redirects: Array<string>;
+};
+
+/** @internal */
+export const RestoreRedirectsRequestBody$outboundSchema: z.ZodType<
+  RestoreRedirectsRequestBody$Outbound,
+  z.ZodTypeDef,
+  RestoreRedirectsRequestBody
+> = z.object({
+  name: z.string().optional(),
+  redirects: z.array(z.string()),
+});
+
+export function restoreRedirectsRequestBodyToJSON(
+  restoreRedirectsRequestBody: RestoreRedirectsRequestBody,
+): string {
+  return JSON.stringify(
+    RestoreRedirectsRequestBody$outboundSchema.parse(
+      restoreRedirectsRequestBody,
+    ),
+  );
+}
+export function restoreRedirectsRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<RestoreRedirectsRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RestoreRedirectsRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RestoreRedirectsRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const RestoreRedirectsRequest$inboundSchema: z.ZodType<
+  RestoreRedirectsRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  projectId: z.string(),
+  teamId: z.string().optional(),
+  slug: z.string().optional(),
+  RequestBody: z.lazy(() => RestoreRedirectsRequestBody$inboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type RestoreRedirectsRequest$Outbound = {
+  projectId: string;
+  teamId?: string | undefined;
+  slug?: string | undefined;
+  RequestBody?: RestoreRedirectsRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const RestoreRedirectsRequest$outboundSchema: z.ZodType<
+  RestoreRedirectsRequest$Outbound,
+  z.ZodTypeDef,
+  RestoreRedirectsRequest
+> = z.object({
+  projectId: z.string(),
+  teamId: z.string().optional(),
+  slug: z.string().optional(),
+  requestBody: z.lazy(() => RestoreRedirectsRequestBody$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function restoreRedirectsRequestToJSON(
+  restoreRedirectsRequest: RestoreRedirectsRequest,
+): string {
+  return JSON.stringify(
+    RestoreRedirectsRequest$outboundSchema.parse(restoreRedirectsRequest),
+  );
+}
+export function restoreRedirectsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<RestoreRedirectsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RestoreRedirectsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RestoreRedirectsRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const RestoreRedirectsVersion$inboundSchema: z.ZodType<
+  RestoreRedirectsVersion,
+  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 RestoreRedirectsVersion$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 RestoreRedirectsVersion$outboundSchema: z.ZodType<
+  RestoreRedirectsVersion$Outbound,
+  z.ZodTypeDef,
+  RestoreRedirectsVersion
+> = 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 restoreRedirectsVersionToJSON(
+  restoreRedirectsVersion: RestoreRedirectsVersion,
+): string {
+  return JSON.stringify(
+    RestoreRedirectsVersion$outboundSchema.parse(restoreRedirectsVersion),
+  );
+}
+export function restoreRedirectsVersionFromJSON(
+  jsonString: string,
+): SafeParseResult<RestoreRedirectsVersion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RestoreRedirectsVersion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RestoreRedirectsVersion' from JSON`,
+  );
+}
+
+/** @internal */
+export const RestoreRedirectsResponseBody$inboundSchema: z.ZodType<
+  RestoreRedirectsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  version: z.lazy(() => RestoreRedirectsVersion$inboundSchema),
+  restored: z.array(z.string()),
+  failedToRestore: z.array(z.string()),
+});
+/** @internal */
+export type RestoreRedirectsResponseBody$Outbound = {
+  version: RestoreRedirectsVersion$Outbound;
+  restored: Array<string>;
+  failedToRestore: Array<string>;
+};
+
+/** @internal */
+export const RestoreRedirectsResponseBody$outboundSchema: z.ZodType<
+  RestoreRedirectsResponseBody$Outbound,
+  z.ZodTypeDef,
+  RestoreRedirectsResponseBody
+> = z.object({
+  version: z.lazy(() => RestoreRedirectsVersion$outboundSchema),
+  restored: z.array(z.string()),
+  failedToRestore: z.array(z.string()),
+});
+
+export function restoreRedirectsResponseBodyToJSON(
+  restoreRedirectsResponseBody: RestoreRedirectsResponseBody,
+): string {
+  return JSON.stringify(
+    RestoreRedirectsResponseBody$outboundSchema.parse(
+      restoreRedirectsResponseBody,
+    ),
+  );
+}
+export function restoreRedirectsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<RestoreRedirectsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RestoreRedirectsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RestoreRedirectsResponseBody' from JSON`,
+  );
+}