@vercel/sdk 1.17.7 → 1.18.0

package/src/models/createedgeconfigop.ts

@@ -5,7 +5,6 @@
 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";
 
@@ -37,25 +36,13 @@ export type CreateEdgeConfigTransfer = {
 
 export type CreateEdgeConfigSchema = {};
 
-export const CreateEdgeConfigPurposeType = {
-  Experimentation: "experimentation",
-} as const;
-export type CreateEdgeConfigPurposeType = ClosedEnum<
-  typeof CreateEdgeConfigPurposeType
->;
-
 export type Purpose2 = {
-  type: CreateEdgeConfigPurposeType;
+  type: "experimentation";
   resourceId: string;
 };
 
-export const PurposeType = {
-  Flags: "flags",
-} as const;
-export type PurposeType = ClosedEnum<typeof PurposeType>;
-
 export type Purpose1 = {
-  type: PurposeType;
+  type: "flags";
   projectId: string;
 };
 
@@ -264,27 +251,18 @@ export function createEdgeConfigSchemaFromJSON(
   );
 }
 
-/** @internal */
-export const CreateEdgeConfigPurposeType$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEdgeConfigPurposeType
-> = z.nativeEnum(CreateEdgeConfigPurposeType);
-/** @internal */
-export const CreateEdgeConfigPurposeType$outboundSchema: z.ZodNativeEnum<
-  typeof CreateEdgeConfigPurposeType
-> = CreateEdgeConfigPurposeType$inboundSchema;
-
 /** @internal */
 export const Purpose2$inboundSchema: z.ZodType<
   Purpose2,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: CreateEdgeConfigPurposeType$inboundSchema,
+  type: z.literal("experimentation"),
   resourceId: z.string(),
 });
 /** @internal */
 export type Purpose2$Outbound = {
-  type: string;
+  type: "experimentation";
   resourceId: string;
 };
 
@@ -294,7 +272,7 @@ export const Purpose2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Purpose2
 > = z.object({
-  type: CreateEdgeConfigPurposeType$outboundSchema,
+  type: z.literal("experimentation"),
   resourceId: z.string(),
 });
 
@@ -311,25 +289,18 @@ export function purpose2FromJSON(
   );
 }
 
-/** @internal */
-export const PurposeType$inboundSchema: z.ZodNativeEnum<typeof PurposeType> = z
-  .nativeEnum(PurposeType);
-/** @internal */
-export const PurposeType$outboundSchema: z.ZodNativeEnum<typeof PurposeType> =
-  PurposeType$inboundSchema;
-
 /** @internal */
 export const Purpose1$inboundSchema: z.ZodType<
   Purpose1,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: PurposeType$inboundSchema,
+  type: z.literal("flags"),
   projectId: z.string(),
 });
 /** @internal */
 export type Purpose1$Outbound = {
-  type: string;
+  type: "flags";
   projectId: string;
 };
 
@@ -339,7 +310,7 @@ export const Purpose1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Purpose1
 > = z.object({
-  type: PurposeType$outboundSchema,
+  type: z.literal("flags"),
   projectId: z.string(),
 });
 

package/src/models/createeventop.ts

@@ -5,17 +5,11 @@
 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 CreateEventEventType = {
-  ResourceUpdated: "resource.updated",
-} as const;
-export type CreateEventEventType = ClosedEnum<typeof CreateEventEventType>;
-
 export type Event2 = {
-  type: CreateEventEventType;
+  type: "resource.updated";
   /**
    * Partner-provided product slug or id
    */
@@ -26,23 +20,18 @@ export type Event2 = {
   resourceId: string;
 };
 
-export const EventType = {
-  InstallationUpdated: "installation.updated",
-} as const;
-export type EventType = ClosedEnum<typeof EventType>;
-
 export type Event1 = {
-  type: EventType;
+  type: "installation.updated";
   /**
    * The installation-level billing plan ID
    */
   billingPlanId?: string | undefined;
 };
 
-export type CreateEventEvent = Event2 | Event1;
+export type CreateEventEvent = Event1 | Event2;
 
 export type CreateEventRequestBody = {
-  event: Event2 | Event1;
+  event: Event1 | Event2;
 };
 
 export type CreateEventRequest = {
@@ -50,25 +39,16 @@ export type CreateEventRequest = {
   requestBody: CreateEventRequestBody;
 };
 
-/** @internal */
-export const CreateEventEventType$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEventEventType
-> = z.nativeEnum(CreateEventEventType);
-/** @internal */
-export const CreateEventEventType$outboundSchema: z.ZodNativeEnum<
-  typeof CreateEventEventType
-> = CreateEventEventType$inboundSchema;
-
 /** @internal */
 export const Event2$inboundSchema: z.ZodType<Event2, z.ZodTypeDef, unknown> = z
   .object({
-    type: CreateEventEventType$inboundSchema,
+    type: z.literal("resource.updated"),
     productId: z.string().optional(),
     resourceId: z.string(),
   });
 /** @internal */
 export type Event2$Outbound = {
-  type: string;
+  type: "resource.updated";
   productId?: string | undefined;
   resourceId: string;
 };
@@ -79,7 +59,7 @@ export const Event2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Event2
 > = z.object({
-  type: CreateEventEventType$outboundSchema,
+  type: z.literal("resource.updated"),
   productId: z.string().optional(),
   resourceId: z.string(),
 });
@@ -97,22 +77,15 @@ export function event2FromJSON(
   );
 }
 
-/** @internal */
-export const EventType$inboundSchema: z.ZodNativeEnum<typeof EventType> = z
-  .nativeEnum(EventType);
-/** @internal */
-export const EventType$outboundSchema: z.ZodNativeEnum<typeof EventType> =
-  EventType$inboundSchema;
-
 /** @internal */
 export const Event1$inboundSchema: z.ZodType<Event1, z.ZodTypeDef, unknown> = z
   .object({
-    type: EventType$inboundSchema,
+    type: z.literal("installation.updated"),
     billingPlanId: z.string().optional(),
   });
 /** @internal */
 export type Event1$Outbound = {
-  type: string;
+  type: "installation.updated";
   billingPlanId?: string | undefined;
 };
 
@@ -122,7 +95,7 @@ export const Event1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Event1
 > = z.object({
-  type: EventType$outboundSchema,
+  type: z.literal("installation.updated"),
   billingPlanId: z.string().optional(),
 });
 
@@ -145,11 +118,11 @@ export const CreateEventEvent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => Event2$inboundSchema),
   z.lazy(() => Event1$inboundSchema),
+  z.lazy(() => Event2$inboundSchema),
 ]);
 /** @internal */
-export type CreateEventEvent$Outbound = Event2$Outbound | Event1$Outbound;
+export type CreateEventEvent$Outbound = Event1$Outbound | Event2$Outbound;
 
 /** @internal */
 export const CreateEventEvent$outboundSchema: z.ZodType<
@@ -157,8 +130,8 @@ export const CreateEventEvent$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateEventEvent
 > = z.union([
-  z.lazy(() => Event2$outboundSchema),
   z.lazy(() => Event1$outboundSchema),
+  z.lazy(() => Event2$outboundSchema),
 ]);
 
 export function createEventEventToJSON(
@@ -185,13 +158,13 @@ export const CreateEventRequestBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   event: z.union([
-    z.lazy(() => Event2$inboundSchema),
     z.lazy(() => Event1$inboundSchema),
+    z.lazy(() => Event2$inboundSchema),
   ]),
 });
 /** @internal */
 export type CreateEventRequestBody$Outbound = {
-  event: Event2$Outbound | Event1$Outbound;
+  event: Event1$Outbound | Event2$Outbound;
 };
 
 /** @internal */
@@ -201,8 +174,8 @@ export const CreateEventRequestBody$outboundSchema: z.ZodType<
   CreateEventRequestBody
 > = z.object({
   event: z.union([
-    z.lazy(() => Event2$outboundSchema),
     z.lazy(() => Event1$outboundSchema),
+    z.lazy(() => Event2$outboundSchema),
   ]),
 });
 

package/src/models/createlogdrainop.ts

@@ -141,35 +141,21 @@ export type CreateLogDrainLogDrainsEnvironments = ClosedEnum<
   typeof CreateLogDrainLogDrainsEnvironments
 >;
 
-export const CreateLogDrainSourceLogDrainsKind = {
-  Integration: "integration",
-} as const;
-export type CreateLogDrainSourceLogDrainsKind = ClosedEnum<
-  typeof CreateLogDrainSourceLogDrainsKind
->;
-
 export type CreateLogDrainSource2 = {
-  kind: CreateLogDrainSourceLogDrainsKind;
+  kind: "integration";
   resourceId?: string | undefined;
   externalResourceId?: string | undefined;
   integrationId: string;
   integrationConfigurationId: string;
 };
 
-export const CreateLogDrainSourceKind = {
-  SelfServed: "self-served",
-} as const;
-export type CreateLogDrainSourceKind = ClosedEnum<
-  typeof CreateLogDrainSourceKind
->;
-
 export type CreateLogDrainSource1 = {
-  kind: CreateLogDrainSourceKind;
+  kind: "self-served";
 };
 
 export type CreateLogDrainSource =
-  | CreateLogDrainSource2
-  | CreateLogDrainSource1;
+  | CreateLogDrainSource1
+  | CreateLogDrainSource2;
 
 /**
  * The log drain was successfully created
@@ -236,7 +222,7 @@ export type CreateLogDrainResponseBody = {
    * The sampling rate of log drain
    */
   samplingRate?: number | undefined;
-  source: CreateLogDrainSource2 | CreateLogDrainSource1;
+  source: CreateLogDrainSource1 | CreateLogDrainSource2;
 };
 
 /** @internal */
@@ -416,22 +402,13 @@ export const CreateLogDrainLogDrainsEnvironments$outboundSchema:
   z.ZodNativeEnum<typeof CreateLogDrainLogDrainsEnvironments> =
     CreateLogDrainLogDrainsEnvironments$inboundSchema;
 
-/** @internal */
-export const CreateLogDrainSourceLogDrainsKind$inboundSchema: z.ZodNativeEnum<
-  typeof CreateLogDrainSourceLogDrainsKind
-> = z.nativeEnum(CreateLogDrainSourceLogDrainsKind);
-/** @internal */
-export const CreateLogDrainSourceLogDrainsKind$outboundSchema: z.ZodNativeEnum<
-  typeof CreateLogDrainSourceLogDrainsKind
-> = CreateLogDrainSourceLogDrainsKind$inboundSchema;
-
 /** @internal */
 export const CreateLogDrainSource2$inboundSchema: z.ZodType<
   CreateLogDrainSource2,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: CreateLogDrainSourceLogDrainsKind$inboundSchema,
+  kind: z.literal("integration"),
   resourceId: z.string().optional(),
   externalResourceId: z.string().optional(),
   integrationId: z.string(),
@@ -439,7 +416,7 @@ export const CreateLogDrainSource2$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type CreateLogDrainSource2$Outbound = {
-  kind: string;
+  kind: "integration";
   resourceId?: string | undefined;
   externalResourceId?: string | undefined;
   integrationId: string;
@@ -452,7 +429,7 @@ export const CreateLogDrainSource2$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateLogDrainSource2
 > = z.object({
-  kind: CreateLogDrainSourceLogDrainsKind$outboundSchema,
+  kind: z.literal("integration"),
   resourceId: z.string().optional(),
   externalResourceId: z.string().optional(),
   integrationId: z.string(),
@@ -476,26 +453,17 @@ export function createLogDrainSource2FromJSON(
   );
 }
 
-/** @internal */
-export const CreateLogDrainSourceKind$inboundSchema: z.ZodNativeEnum<
-  typeof CreateLogDrainSourceKind
-> = z.nativeEnum(CreateLogDrainSourceKind);
-/** @internal */
-export const CreateLogDrainSourceKind$outboundSchema: z.ZodNativeEnum<
-  typeof CreateLogDrainSourceKind
-> = CreateLogDrainSourceKind$inboundSchema;
-
 /** @internal */
 export const CreateLogDrainSource1$inboundSchema: z.ZodType<
   CreateLogDrainSource1,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  kind: CreateLogDrainSourceKind$inboundSchema,
+  kind: z.literal("self-served"),
 });
 /** @internal */
 export type CreateLogDrainSource1$Outbound = {
-  kind: string;
+  kind: "self-served";
 };
 
 /** @internal */
@@ -504,7 +472,7 @@ export const CreateLogDrainSource1$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateLogDrainSource1
 > = z.object({
-  kind: CreateLogDrainSourceKind$outboundSchema,
+  kind: z.literal("self-served"),
 });
 
 export function createLogDrainSource1ToJSON(
@@ -530,13 +498,13 @@ export const CreateLogDrainSource$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => CreateLogDrainSource2$inboundSchema),
   z.lazy(() => CreateLogDrainSource1$inboundSchema),
+  z.lazy(() => CreateLogDrainSource2$inboundSchema),
 ]);
 /** @internal */
 export type CreateLogDrainSource$Outbound =
-  | CreateLogDrainSource2$Outbound
-  | CreateLogDrainSource1$Outbound;
+  | CreateLogDrainSource1$Outbound
+  | CreateLogDrainSource2$Outbound;
 
 /** @internal */
 export const CreateLogDrainSource$outboundSchema: z.ZodType<
@@ -544,8 +512,8 @@ export const CreateLogDrainSource$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateLogDrainSource
 > = z.union([
-  z.lazy(() => CreateLogDrainSource2$outboundSchema),
   z.lazy(() => CreateLogDrainSource1$outboundSchema),
+  z.lazy(() => CreateLogDrainSource2$outboundSchema),
 ]);
 
 export function createLogDrainSourceToJSON(
@@ -590,8 +558,8 @@ export const CreateLogDrainResponseBody$inboundSchema: z.ZodType<
   branch: z.string().optional(),
   samplingRate: z.number().optional(),
   source: z.union([
-    z.lazy(() => CreateLogDrainSource2$inboundSchema),
     z.lazy(() => CreateLogDrainSource1$inboundSchema),
+    z.lazy(() => CreateLogDrainSource2$inboundSchema),
   ]),
 });
 /** @internal */
@@ -612,7 +580,7 @@ export type CreateLogDrainResponseBody$Outbound = {
   environments?: Array<string> | undefined;
   branch?: string | undefined;
   samplingRate?: number | undefined;
-  source: CreateLogDrainSource2$Outbound | CreateLogDrainSource1$Outbound;
+  source: CreateLogDrainSource1$Outbound | CreateLogDrainSource2$Outbound;
 };
 
 /** @internal */
@@ -640,8 +608,8 @@ export const CreateLogDrainResponseBody$outboundSchema: z.ZodType<
   branch: z.string().optional(),
   samplingRate: z.number().optional(),
   source: z.union([
-    z.lazy(() => CreateLogDrainSource2$outboundSchema),
     z.lazy(() => CreateLogDrainSource1$outboundSchema),
+    z.lazy(() => CreateLogDrainSource2$outboundSchema),
   ]),
 });