@vercel/sdk 1.18.6 → 1.18.7

package/src/models/updateaccessgroupop.ts

@@ -23,7 +23,7 @@ export const UpdateAccessGroupRole = {
  */
 export type UpdateAccessGroupRole = ClosedEnum<typeof UpdateAccessGroupRole>;
 
-export type Projects = {
+export type UpdateAccessGroupProjects = {
   /**
    * The ID of the project.
    */
@@ -39,7 +39,7 @@ export type UpdateAccessGroupRequestBody = {
    * The name of the access group
    */
   name?: string | undefined;
-  projects?: Array<Projects> | undefined;
+  projects?: Array<UpdateAccessGroupProjects> | undefined;
   /**
    * List of members to add to the access group.
    */
@@ -120,8 +120,8 @@ export const UpdateAccessGroupRole$outboundSchema: z.ZodNativeEnum<
 > = UpdateAccessGroupRole$inboundSchema;
 
 /** @internal */
-export const Projects$inboundSchema: z.ZodType<
-  Projects,
+export const UpdateAccessGroupProjects$inboundSchema: z.ZodType<
+  UpdateAccessGroupProjects,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -129,31 +129,35 @@ export const Projects$inboundSchema: z.ZodType<
   role: types.nullable(UpdateAccessGroupRole$inboundSchema),
 });
 /** @internal */
-export type Projects$Outbound = {
+export type UpdateAccessGroupProjects$Outbound = {
   projectId: string;
   role: string | null;
 };
 
 /** @internal */
-export const Projects$outboundSchema: z.ZodType<
-  Projects$Outbound,
+export const UpdateAccessGroupProjects$outboundSchema: z.ZodType<
+  UpdateAccessGroupProjects$Outbound,
   z.ZodTypeDef,
-  Projects
+  UpdateAccessGroupProjects
 > = z.object({
   projectId: z.string(),
   role: z.nullable(UpdateAccessGroupRole$outboundSchema),
 });
 
-export function projectsToJSON(projects: Projects): string {
-  return JSON.stringify(Projects$outboundSchema.parse(projects));
+export function updateAccessGroupProjectsToJSON(
+  updateAccessGroupProjects: UpdateAccessGroupProjects,
+): string {
+  return JSON.stringify(
+    UpdateAccessGroupProjects$outboundSchema.parse(updateAccessGroupProjects),
+  );
 }
-export function projectsFromJSON(
+export function updateAccessGroupProjectsFromJSON(
   jsonString: string,
-): SafeParseResult<Projects, SDKValidationError> {
+): SafeParseResult<UpdateAccessGroupProjects, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Projects$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Projects' from JSON`,
+    (x) => UpdateAccessGroupProjects$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateAccessGroupProjects' from JSON`,
   );
 }
 
@@ -164,14 +168,16 @@ export const UpdateAccessGroupRequestBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   name: types.optional(types.string()),
-  projects: types.optional(z.array(z.lazy(() => Projects$inboundSchema))),
+  projects: types.optional(
+    z.array(z.lazy(() => UpdateAccessGroupProjects$inboundSchema)),
+  ),
   membersToAdd: types.optional(z.array(types.string())),
   membersToRemove: types.optional(z.array(types.string())),
 });
 /** @internal */
 export type UpdateAccessGroupRequestBody$Outbound = {
   name?: string | undefined;
-  projects?: Array<Projects$Outbound> | undefined;
+  projects?: Array<UpdateAccessGroupProjects$Outbound> | undefined;
   membersToAdd?: Array<string> | undefined;
   membersToRemove?: Array<string> | undefined;
 };
@@ -183,7 +189,8 @@ export const UpdateAccessGroupRequestBody$outboundSchema: z.ZodType<
   UpdateAccessGroupRequestBody
 > = z.object({
   name: z.string().optional(),
-  projects: z.array(z.lazy(() => Projects$outboundSchema)).optional(),
+  projects: z.array(z.lazy(() => UpdateAccessGroupProjects$outboundSchema))
+    .optional(),
   membersToAdd: z.array(z.string()).optional(),
   membersToRemove: z.array(z.string()).optional(),
 });

package/src/models/updateattackchallengemodeop.ts

@@ -7,14 +7,24 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
+import { smartUnion } from "../types/smartUnion.js";
 import { SDKValidationError } from "./sdkvalidationerror.js";
 
-export type UpdateAttackChallengeModeRequestBody = {
+export type UpdateAttackChallengeModeRequestBody2 = {
   projectId: string;
   attackModeEnabled: boolean;
-  attackModeActiveUntil?: number | null | undefined;
 };
 
+export type UpdateAttackChallengeModeRequestBody1 = {
+  projectId: string;
+  attackModeEnabled: boolean;
+  attackModeActiveUntil: number;
+};
+
+export type UpdateAttackChallengeModeRequestBody =
+  | UpdateAttackChallengeModeRequestBody1
+  | UpdateAttackChallengeModeRequestBody2;
+
 export type UpdateAttackChallengeModeRequest = {
   /**
    * The Team identifier to perform the request on behalf of.
@@ -24,7 +34,9 @@ export type UpdateAttackChallengeModeRequest = {
    * The Team slug to perform the request on behalf of.
    */
   slug?: string | undefined;
-  requestBody: UpdateAttackChallengeModeRequestBody;
+  requestBody:
+    | UpdateAttackChallengeModeRequestBody1
+    | UpdateAttackChallengeModeRequestBody2;
 };
 
 export type UpdateAttackChallengeModeResponseBody = {
@@ -33,33 +45,122 @@ export type UpdateAttackChallengeModeResponseBody = {
 };
 
 /** @internal */
-export const UpdateAttackChallengeModeRequestBody$inboundSchema: z.ZodType<
-  UpdateAttackChallengeModeRequestBody,
+export const UpdateAttackChallengeModeRequestBody2$inboundSchema: z.ZodType<
+  UpdateAttackChallengeModeRequestBody2,
   z.ZodTypeDef,
   unknown
 > = z.object({
   projectId: types.string(),
   attackModeEnabled: types.boolean(),
-  attackModeActiveUntil: z.nullable(types.number()).optional(),
 });
 /** @internal */
-export type UpdateAttackChallengeModeRequestBody$Outbound = {
+export type UpdateAttackChallengeModeRequestBody2$Outbound = {
   projectId: string;
   attackModeEnabled: boolean;
-  attackModeActiveUntil?: number | null | undefined;
 };
 
 /** @internal */
-export const UpdateAttackChallengeModeRequestBody$outboundSchema: z.ZodType<
-  UpdateAttackChallengeModeRequestBody$Outbound,
+export const UpdateAttackChallengeModeRequestBody2$outboundSchema: z.ZodType<
+  UpdateAttackChallengeModeRequestBody2$Outbound,
   z.ZodTypeDef,
-  UpdateAttackChallengeModeRequestBody
+  UpdateAttackChallengeModeRequestBody2
+> = z.object({
+  projectId: z.string(),
+  attackModeEnabled: z.boolean(),
+});
+
+export function updateAttackChallengeModeRequestBody2ToJSON(
+  updateAttackChallengeModeRequestBody2: UpdateAttackChallengeModeRequestBody2,
+): string {
+  return JSON.stringify(
+    UpdateAttackChallengeModeRequestBody2$outboundSchema.parse(
+      updateAttackChallengeModeRequestBody2,
+    ),
+  );
+}
+export function updateAttackChallengeModeRequestBody2FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateAttackChallengeModeRequestBody2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateAttackChallengeModeRequestBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateAttackChallengeModeRequestBody2' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateAttackChallengeModeRequestBody1$inboundSchema: z.ZodType<
+  UpdateAttackChallengeModeRequestBody1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  projectId: types.string(),
+  attackModeEnabled: types.boolean(),
+  attackModeActiveUntil: types.number(),
+});
+/** @internal */
+export type UpdateAttackChallengeModeRequestBody1$Outbound = {
+  projectId: string;
+  attackModeEnabled: boolean;
+  attackModeActiveUntil: number;
+};
+
+/** @internal */
+export const UpdateAttackChallengeModeRequestBody1$outboundSchema: z.ZodType<
+  UpdateAttackChallengeModeRequestBody1$Outbound,
+  z.ZodTypeDef,
+  UpdateAttackChallengeModeRequestBody1
 > = z.object({
   projectId: z.string(),
   attackModeEnabled: z.boolean(),
-  attackModeActiveUntil: z.nullable(z.number()).optional(),
+  attackModeActiveUntil: z.number(),
 });
 
+export function updateAttackChallengeModeRequestBody1ToJSON(
+  updateAttackChallengeModeRequestBody1: UpdateAttackChallengeModeRequestBody1,
+): string {
+  return JSON.stringify(
+    UpdateAttackChallengeModeRequestBody1$outboundSchema.parse(
+      updateAttackChallengeModeRequestBody1,
+    ),
+  );
+}
+export function updateAttackChallengeModeRequestBody1FromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateAttackChallengeModeRequestBody1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateAttackChallengeModeRequestBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateAttackChallengeModeRequestBody1' from JSON`,
+  );
+}
+
+/** @internal */
+export const UpdateAttackChallengeModeRequestBody$inboundSchema: z.ZodType<
+  UpdateAttackChallengeModeRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = smartUnion([
+  z.lazy(() => UpdateAttackChallengeModeRequestBody1$inboundSchema),
+  z.lazy(() => UpdateAttackChallengeModeRequestBody2$inboundSchema),
+]);
+/** @internal */
+export type UpdateAttackChallengeModeRequestBody$Outbound =
+  | UpdateAttackChallengeModeRequestBody1$Outbound
+  | UpdateAttackChallengeModeRequestBody2$Outbound;
+
+/** @internal */
+export const UpdateAttackChallengeModeRequestBody$outboundSchema: z.ZodType<
+  UpdateAttackChallengeModeRequestBody$Outbound,
+  z.ZodTypeDef,
+  UpdateAttackChallengeModeRequestBody
+> = smartUnion([
+  z.lazy(() => UpdateAttackChallengeModeRequestBody1$outboundSchema),
+  z.lazy(() => UpdateAttackChallengeModeRequestBody2$outboundSchema),
+]);
+
 export function updateAttackChallengeModeRequestBodyToJSON(
   updateAttackChallengeModeRequestBody: UpdateAttackChallengeModeRequestBody,
 ): string {
@@ -88,7 +189,10 @@ export const UpdateAttackChallengeModeRequest$inboundSchema: z.ZodType<
 > = z.object({
   teamId: types.optional(types.string()),
   slug: types.optional(types.string()),
-  RequestBody: z.lazy(() => UpdateAttackChallengeModeRequestBody$inboundSchema),
+  RequestBody: smartUnion([
+    z.lazy(() => UpdateAttackChallengeModeRequestBody1$inboundSchema),
+    z.lazy(() => UpdateAttackChallengeModeRequestBody2$inboundSchema),
+  ]),
 }).transform((v) => {
   return remap$(v, {
     "RequestBody": "requestBody",
@@ -98,7 +202,9 @@ export const UpdateAttackChallengeModeRequest$inboundSchema: z.ZodType<
 export type UpdateAttackChallengeModeRequest$Outbound = {
   teamId?: string | undefined;
   slug?: string | undefined;
-  RequestBody: UpdateAttackChallengeModeRequestBody$Outbound;
+  RequestBody:
+    | UpdateAttackChallengeModeRequestBody1$Outbound
+    | UpdateAttackChallengeModeRequestBody2$Outbound;
 };
 
 /** @internal */
@@ -109,9 +215,10 @@ export const UpdateAttackChallengeModeRequest$outboundSchema: z.ZodType<
 > = z.object({
   teamId: z.string().optional(),
   slug: z.string().optional(),
-  requestBody: z.lazy(() =>
-    UpdateAttackChallengeModeRequestBody$outboundSchema
-  ),
+  requestBody: smartUnion([
+    z.lazy(() => UpdateAttackChallengeModeRequestBody1$outboundSchema),
+    z.lazy(() => UpdateAttackChallengeModeRequestBody2$outboundSchema),
+  ]),
 }).transform((v) => {
   return remap$(v, {
     requestBody: "RequestBody",

package/src/models/updatecheckop.ts

@@ -13,14 +13,14 @@ import { SDKValidationError } from "./sdkvalidationerror.js";
 /**
  * The current status of the check
  */
-export const Status = {
+export const UpdateCheckStatus = {
   Running: "running",
   Completed: "completed",
 } as const;
 /**
  * The current status of the check
  */
-export type Status = ClosedEnum<typeof Status>;
+export type UpdateCheckStatus = ClosedEnum<typeof UpdateCheckStatus>;
 
 /**
  * The result of the check being run
@@ -163,7 +163,7 @@ export type UpdateCheckRequestBody = {
   /**
    * The current status of the check
    */
-  status?: Status | undefined;
+  status?: UpdateCheckStatus | undefined;
   /**
    * The result of the check being run
    */
@@ -202,12 +202,14 @@ export type UpdateCheckRequest = {
   requestBody: UpdateCheckRequestBody;
 };
 
-export const UpdateCheckStatus = {
+export const UpdateCheckChecksStatus = {
   Registered: "registered",
   Running: "running",
   Completed: "completed",
 } as const;
-export type UpdateCheckStatus = ClosedEnum<typeof UpdateCheckStatus>;
+export type UpdateCheckChecksStatus = ClosedEnum<
+  typeof UpdateCheckChecksStatus
+>;
 
 export const UpdateCheckConclusion = {
   Canceled: "canceled",
@@ -303,7 +305,7 @@ export type UpdateCheckResponseBody = {
   id: string;
   name: string;
   path?: string | undefined;
-  status: UpdateCheckStatus;
+  status: UpdateCheckChecksStatus;
   conclusion?: UpdateCheckConclusion | undefined;
   blocking: boolean;
   output?: UpdateCheckOutput | undefined;
@@ -319,11 +321,13 @@ export type UpdateCheckResponseBody = {
 };
 
 /** @internal */
-export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
-  .nativeEnum(Status);
+export const UpdateCheckStatus$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateCheckStatus
+> = z.nativeEnum(UpdateCheckStatus);
 /** @internal */
-export const Status$outboundSchema: z.ZodNativeEnum<typeof Status> =
-  Status$inboundSchema;
+export const UpdateCheckStatus$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateCheckStatus
+> = UpdateCheckStatus$inboundSchema;
 
 /** @internal */
 export const Conclusion$inboundSchema: z.ZodNativeEnum<typeof Conclusion> = z
@@ -663,7 +667,7 @@ export const UpdateCheckRequestBody$inboundSchema: z.ZodType<
 > = z.object({
   name: types.optional(types.string()),
   path: types.optional(types.string()),
-  status: types.optional(Status$inboundSchema),
+  status: types.optional(UpdateCheckStatus$inboundSchema),
   conclusion: types.optional(Conclusion$inboundSchema),
   detailsUrl: types.optional(types.string()),
   output: types.optional(z.lazy(() => Output$inboundSchema)),
@@ -688,7 +692,7 @@ export const UpdateCheckRequestBody$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string().optional(),
   path: z.string().optional(),
-  status: Status$outboundSchema.optional(),
+  status: UpdateCheckStatus$outboundSchema.optional(),
   conclusion: Conclusion$outboundSchema.optional(),
   detailsUrl: z.string().optional(),
   output: z.lazy(() => Output$outboundSchema).optional(),
@@ -772,13 +776,13 @@ export function updateCheckRequestFromJSON(
 }
 
 /** @internal */
-export const UpdateCheckStatus$inboundSchema: z.ZodNativeEnum<
-  typeof UpdateCheckStatus
-> = z.nativeEnum(UpdateCheckStatus);
+export const UpdateCheckChecksStatus$inboundSchema: z.ZodNativeEnum<
+  typeof UpdateCheckChecksStatus
+> = z.nativeEnum(UpdateCheckChecksStatus);
 /** @internal */
-export const UpdateCheckStatus$outboundSchema: z.ZodNativeEnum<
-  typeof UpdateCheckStatus
-> = UpdateCheckStatus$inboundSchema;
+export const UpdateCheckChecksStatus$outboundSchema: z.ZodNativeEnum<
+  typeof UpdateCheckChecksStatus
+> = UpdateCheckChecksStatus$inboundSchema;
 
 /** @internal */
 export const UpdateCheckConclusion$inboundSchema: z.ZodNativeEnum<
@@ -1178,7 +1182,7 @@ export const UpdateCheckResponseBody$inboundSchema: z.ZodType<
   id: types.string(),
   name: types.string(),
   path: types.optional(types.string()),
-  status: UpdateCheckStatus$inboundSchema,
+  status: UpdateCheckChecksStatus$inboundSchema,
   conclusion: types.optional(UpdateCheckConclusion$inboundSchema),
   blocking: types.boolean(),
   output: types.optional(z.lazy(() => UpdateCheckOutput$inboundSchema)),
@@ -1221,7 +1225,7 @@ export const UpdateCheckResponseBody$outboundSchema: z.ZodType<
   id: z.string(),
   name: z.string(),
   path: z.string().optional(),
-  status: UpdateCheckStatus$outboundSchema,
+  status: UpdateCheckChecksStatus$outboundSchema,
   conclusion: UpdateCheckConclusion$outboundSchema.optional(),
   blocking: z.boolean(),
   output: z.lazy(() => UpdateCheckOutput$outboundSchema).optional(),