@meetkai/mka1 0.49.14 → 0.49.16

package/src/models/components/addcatalogmodelrequest.ts

@@ -0,0 +1,2000 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AutoEndpoint,
+  AutoEndpoint$inboundSchema,
+  AutoEndpoint$outboundSchema,
+} from "./autoendpoint.js";
+
+export const ApiProviderType = {
+  Groq: "groq",
+  Azure: "azure",
+  Meetkai: "meetkai",
+  MeetkaiGateway: "meetkaiGateway",
+  Fal: "fal",
+  Openai: "openai",
+} as const;
+export type ApiProviderType = ClosedEnum<typeof ApiProviderType>;
+
+export type AddCatalogModelRequestStrategies4 = {
+  type: "composite";
+  strategies?: any | undefined;
+};
+
+export type AddCatalogModelRequestStrategies3 = {
+  type: "none";
+};
+
+export type AddCatalogModelRequestStrategies2 = {
+  type: "custom-headers";
+  headers: { [k: string]: string };
+  envVars?: { [k: string]: string } | undefined;
+};
+
+export type AddCatalogModelRequestStrategies1 = {
+  type: "api-key";
+  value?: string | undefined;
+  envVar?: string | undefined;
+  headerName?: string | undefined;
+};
+
+export type StrategiesStrategies =
+  | AddCatalogModelRequestStrategies1
+  | AddCatalogModelRequestStrategies2
+  | AddCatalogModelRequestStrategies3
+  | AddCatalogModelRequestStrategies4;
+
+export type Strategies4 = {
+  type: "composite";
+  strategies: Array<
+    | AddCatalogModelRequestStrategies1
+    | AddCatalogModelRequestStrategies2
+    | AddCatalogModelRequestStrategies3
+    | AddCatalogModelRequestStrategies4
+  >;
+};
+
+export type Strategies3 = {
+  type: "none";
+};
+
+export type Strategies2 = {
+  type: "custom-headers";
+  headers: { [k: string]: string };
+  envVars?: { [k: string]: string } | undefined;
+};
+
+export type Strategies1 = {
+  type: "api-key";
+  value?: string | undefined;
+  envVar?: string | undefined;
+  headerName?: string | undefined;
+};
+
+export type Strategies = Strategies1 | Strategies2 | Strategies3 | Strategies4;
+
+export type Auth4 = {
+  type: "composite";
+  strategies: Array<Strategies1 | Strategies2 | Strategies3 | Strategies4>;
+};
+
+export type Auth3 = {
+  type: "none";
+};
+
+export type Auth2 = {
+  type: "custom-headers";
+  headers: { [k: string]: string };
+  envVars?: { [k: string]: string } | undefined;
+};
+
+export type Auth1 = {
+  type: "api-key";
+  value?: string | undefined;
+  envVar?: string | undefined;
+  headerName?: string | undefined;
+};
+
+export type Auth = Auth1 | Auth2 | Auth3 | Auth4;
+
+export const AddCatalogModelRequestInput = {
+  Text: "text",
+  Image: "image",
+  Audio: "audio",
+  Video: "video",
+} as const;
+export type AddCatalogModelRequestInput = ClosedEnum<
+  typeof AddCatalogModelRequestInput
+>;
+
+export const AddCatalogModelRequestOutput = {
+  Text: "text",
+  Image: "image",
+  Audio: "audio",
+  Video: "video",
+} as const;
+export type AddCatalogModelRequestOutput = ClosedEnum<
+  typeof AddCatalogModelRequestOutput
+>;
+
+export type AddCatalogModelRequestModalities = {
+  input: Array<AddCatalogModelRequestInput>;
+  output: Array<AddCatalogModelRequestOutput>;
+};
+
+export type MaxImageResolution = {
+  maxWidth: number;
+  maxHeight: number;
+};
+
+export type MinImageResolution = {
+  maxWidth: number;
+  maxHeight: number;
+};
+
+export type Capabilities = {
+  modalities: AddCatalogModelRequestModalities;
+  reasoning: boolean;
+  supportedBase64Formats?: Array<string> | undefined;
+  supportsCompletionVideoUrlMessage?: boolean | undefined;
+  supportsTemperature?: boolean | undefined;
+  supportsTopP?: boolean | undefined;
+  maxImageResolution?: MaxImageResolution | undefined;
+  minImageResolution?: MinImageResolution | undefined;
+};
+
+export const Scope = {
+  Global: "global",
+  Org: "org",
+  User: "user",
+  ApiKey: "apiKey",
+  ExternalUser: "externalUser",
+} as const;
+export type Scope = ClosedEnum<typeof Scope>;
+
+export type Queue = {
+  maxDepth: number;
+  maxWaitMs: number;
+};
+
+export type RateLimits = {
+  scope: Scope;
+  rpm: number;
+  duration?: number | undefined;
+  queue?: Queue | undefined;
+};
+
+export type Concurrency = {
+  max: number;
+  maxWaitMs?: number | undefined;
+};
+
+export type DefaultParams = {
+  temperature?: number | undefined;
+  topP?: number | undefined;
+  presencePenalty?: number | undefined;
+  frequencyPenalty?: number | undefined;
+};
+
+export type Trigger4 = {
+  type: "error-fallback";
+};
+
+export type Trigger3 = {
+  type: "context-exceeded";
+};
+
+export type Trigger2 = {
+  type: "base64-input";
+};
+
+export const Modality = {
+  Text: "text",
+  Image: "image",
+  Audio: "audio",
+  Video: "video",
+} as const;
+export type Modality = ClosedEnum<typeof Modality>;
+
+export type Trigger1 = {
+  type: "input-modality";
+  modality: Modality;
+};
+
+export type Trigger = Trigger1 | Trigger2 | Trigger3 | Trigger4;
+
+export type RerouteRules = {
+  trigger: Trigger1 | Trigger2 | Trigger3 | Trigger4;
+  targetModelId: string;
+  preserveParams?: boolean | undefined;
+  log?: boolean | undefined;
+};
+
+export type Dimensions2 = {
+  min: number;
+  max: number;
+  default: number;
+};
+
+export type Dimensions = Dimensions2 | number;
+
+export type EmbeddingLimits = {
+  maxBatchSize?: number | undefined;
+  dimensions?: Dimensions2 | number | undefined;
+};
+
+export const AddCatalogModelRequestHealthCheckMethod = {
+  Get: "GET",
+  Head: "HEAD",
+} as const;
+export type AddCatalogModelRequestHealthCheckMethod = ClosedEnum<
+  typeof AddCatalogModelRequestHealthCheckMethod
+>;
+
+export type HealthCheck3 = {
+  mode: "periodic";
+  intervalSeconds: number;
+  path: string;
+  method?: AddCatalogModelRequestHealthCheckMethod | undefined;
+  timeoutMs?: number | undefined;
+  cacheTtlSeconds?: number | undefined;
+};
+
+export const HealthCheckMethod = {
+  Get: "GET",
+  Head: "HEAD",
+} as const;
+export type HealthCheckMethod = ClosedEnum<typeof HealthCheckMethod>;
+
+export type HealthCheck2 = {
+  mode: "preflight";
+  path: string;
+  method?: HealthCheckMethod | undefined;
+  timeoutMs?: number | undefined;
+  cacheTtlSeconds?: number | undefined;
+};
+
+export type HealthCheck1 = {
+  mode: "off";
+};
+
+export type HealthCheck = HealthCheck1 | HealthCheck2 | HealthCheck3;
+
+export type AddCatalogModelRequest = {
+  id: string;
+  provider: string;
+  modelId: string;
+  displayName?: string | undefined;
+  baseUrl?: string | undefined;
+  apiFormat: AutoEndpoint;
+  apiProviderType: ApiProviderType;
+  created: number;
+  auth: Auth1 | Auth2 | Auth3 | Auth4;
+  capabilities: Capabilities;
+  contextWindow?: number | undefined;
+  rpm?: number | undefined;
+  rateLimits?: Array<RateLimits> | undefined;
+  concurrency?: Concurrency | undefined;
+  requestTimeoutMs?: number | undefined;
+  maxRetries?: number | undefined;
+  defaultParams?: DefaultParams | undefined;
+  rerouteRules?: Array<RerouteRules> | undefined;
+  hidden?: boolean | undefined;
+  embeddingLimits?: EmbeddingLimits | undefined;
+  healthCheck?: HealthCheck1 | HealthCheck2 | HealthCheck3 | undefined;
+};
+
+/** @internal */
+export const ApiProviderType$inboundSchema: z.ZodNativeEnum<
+  typeof ApiProviderType
+> = z.nativeEnum(ApiProviderType);
+/** @internal */
+export const ApiProviderType$outboundSchema: z.ZodNativeEnum<
+  typeof ApiProviderType
+> = ApiProviderType$inboundSchema;
+
+/** @internal */
+export const AddCatalogModelRequestStrategies4$inboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies4,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("composite"),
+  strategies: z.any().optional(),
+});
+/** @internal */
+export type AddCatalogModelRequestStrategies4$Outbound = {
+  type: "composite";
+  strategies?: any | undefined;
+};
+
+/** @internal */
+export const AddCatalogModelRequestStrategies4$outboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies4$Outbound,
+  z.ZodTypeDef,
+  AddCatalogModelRequestStrategies4
+> = z.object({
+  type: z.literal("composite"),
+  strategies: z.any().optional(),
+});
+
+export function addCatalogModelRequestStrategies4ToJSON(
+  addCatalogModelRequestStrategies4: AddCatalogModelRequestStrategies4,
+): string {
+  return JSON.stringify(
+    AddCatalogModelRequestStrategies4$outboundSchema.parse(
+      addCatalogModelRequestStrategies4,
+    ),
+  );
+}
+export function addCatalogModelRequestStrategies4FromJSON(
+  jsonString: string,
+): SafeParseResult<AddCatalogModelRequestStrategies4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddCatalogModelRequestStrategies4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddCatalogModelRequestStrategies4' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddCatalogModelRequestStrategies3$inboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("none"),
+});
+/** @internal */
+export type AddCatalogModelRequestStrategies3$Outbound = {
+  type: "none";
+};
+
+/** @internal */
+export const AddCatalogModelRequestStrategies3$outboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies3$Outbound,
+  z.ZodTypeDef,
+  AddCatalogModelRequestStrategies3
+> = z.object({
+  type: z.literal("none"),
+});
+
+export function addCatalogModelRequestStrategies3ToJSON(
+  addCatalogModelRequestStrategies3: AddCatalogModelRequestStrategies3,
+): string {
+  return JSON.stringify(
+    AddCatalogModelRequestStrategies3$outboundSchema.parse(
+      addCatalogModelRequestStrategies3,
+    ),
+  );
+}
+export function addCatalogModelRequestStrategies3FromJSON(
+  jsonString: string,
+): SafeParseResult<AddCatalogModelRequestStrategies3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddCatalogModelRequestStrategies3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddCatalogModelRequestStrategies3' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddCatalogModelRequestStrategies2$inboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("custom-headers"),
+  headers: z.record(z.string()),
+  envVars: z.record(z.string()).optional(),
+});
+/** @internal */
+export type AddCatalogModelRequestStrategies2$Outbound = {
+  type: "custom-headers";
+  headers: { [k: string]: string };
+  envVars?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const AddCatalogModelRequestStrategies2$outboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies2$Outbound,
+  z.ZodTypeDef,
+  AddCatalogModelRequestStrategies2
+> = z.object({
+  type: z.literal("custom-headers"),
+  headers: z.record(z.string()),
+  envVars: z.record(z.string()).optional(),
+});
+
+export function addCatalogModelRequestStrategies2ToJSON(
+  addCatalogModelRequestStrategies2: AddCatalogModelRequestStrategies2,
+): string {
+  return JSON.stringify(
+    AddCatalogModelRequestStrategies2$outboundSchema.parse(
+      addCatalogModelRequestStrategies2,
+    ),
+  );
+}
+export function addCatalogModelRequestStrategies2FromJSON(
+  jsonString: string,
+): SafeParseResult<AddCatalogModelRequestStrategies2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddCatalogModelRequestStrategies2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddCatalogModelRequestStrategies2' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddCatalogModelRequestStrategies1$inboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("api-key"),
+  value: z.string().optional(),
+  envVar: z.string().optional(),
+  headerName: z.string().optional(),
+});
+/** @internal */
+export type AddCatalogModelRequestStrategies1$Outbound = {
+  type: "api-key";
+  value?: string | undefined;
+  envVar?: string | undefined;
+  headerName?: string | undefined;
+};
+
+/** @internal */
+export const AddCatalogModelRequestStrategies1$outboundSchema: z.ZodType<
+  AddCatalogModelRequestStrategies1$Outbound,
+  z.ZodTypeDef,
+  AddCatalogModelRequestStrategies1
+> = z.object({
+  type: z.literal("api-key"),
+  value: z.string().optional(),
+  envVar: z.string().optional(),
+  headerName: z.string().optional(),
+});
+
+export function addCatalogModelRequestStrategies1ToJSON(
+  addCatalogModelRequestStrategies1: AddCatalogModelRequestStrategies1,
+): string {
+  return JSON.stringify(
+    AddCatalogModelRequestStrategies1$outboundSchema.parse(
+      addCatalogModelRequestStrategies1,
+    ),
+  );
+}
+export function addCatalogModelRequestStrategies1FromJSON(
+  jsonString: string,
+): SafeParseResult<AddCatalogModelRequestStrategies1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddCatalogModelRequestStrategies1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddCatalogModelRequestStrategies1' from JSON`,
+  );
+}
+
+/** @internal */
+export const StrategiesStrategies$inboundSchema: z.ZodType<
+  StrategiesStrategies,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => AddCatalogModelRequestStrategies1$inboundSchema),
+  z.lazy(() => AddCatalogModelRequestStrategies2$inboundSchema),
+  z.lazy(() => AddCatalogModelRequestStrategies3$inboundSchema),
+  z.lazy(() => AddCatalogModelRequestStrategies4$inboundSchema),
+]);
+/** @internal */
+export type StrategiesStrategies$Outbound =
+  | AddCatalogModelRequestStrategies1$Outbound
+  | AddCatalogModelRequestStrategies2$Outbound
+  | AddCatalogModelRequestStrategies3$Outbound
+  | AddCatalogModelRequestStrategies4$Outbound;
+
+/** @internal */
+export const StrategiesStrategies$outboundSchema: z.ZodType<
+  StrategiesStrategies$Outbound,
+  z.ZodTypeDef,
+  StrategiesStrategies
+> = z.union([
+  z.lazy(() => AddCatalogModelRequestStrategies1$outboundSchema),
+  z.lazy(() => AddCatalogModelRequestStrategies2$outboundSchema),
+  z.lazy(() => AddCatalogModelRequestStrategies3$outboundSchema),
+  z.lazy(() => AddCatalogModelRequestStrategies4$outboundSchema),
+]);
+
+export function strategiesStrategiesToJSON(
+  strategiesStrategies: StrategiesStrategies,
+): string {
+  return JSON.stringify(
+    StrategiesStrategies$outboundSchema.parse(strategiesStrategies),
+  );
+}
+export function strategiesStrategiesFromJSON(
+  jsonString: string,
+): SafeParseResult<StrategiesStrategies, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StrategiesStrategies$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StrategiesStrategies' from JSON`,
+  );
+}
+
+/** @internal */
+export const Strategies4$inboundSchema: z.ZodType<
+  Strategies4,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("composite"),
+  strategies: z.array(
+    z.union([
+      z.lazy(() => AddCatalogModelRequestStrategies1$inboundSchema),
+      z.lazy(() => AddCatalogModelRequestStrategies2$inboundSchema),
+      z.lazy(() => AddCatalogModelRequestStrategies3$inboundSchema),
+      z.lazy(() => AddCatalogModelRequestStrategies4$inboundSchema),
+    ]),
+  ),
+});
+/** @internal */
+export type Strategies4$Outbound = {
+  type: "composite";
+  strategies: Array<
+    | AddCatalogModelRequestStrategies1$Outbound
+    | AddCatalogModelRequestStrategies2$Outbound
+    | AddCatalogModelRequestStrategies3$Outbound
+    | AddCatalogModelRequestStrategies4$Outbound
+  >;
+};
+
+/** @internal */
+export const Strategies4$outboundSchema: z.ZodType<
+  Strategies4$Outbound,
+  z.ZodTypeDef,
+  Strategies4
+> = z.object({
+  type: z.literal("composite"),
+  strategies: z.array(
+    z.union([
+      z.lazy(() => AddCatalogModelRequestStrategies1$outboundSchema),
+      z.lazy(() => AddCatalogModelRequestStrategies2$outboundSchema),
+      z.lazy(() => AddCatalogModelRequestStrategies3$outboundSchema),
+      z.lazy(() => AddCatalogModelRequestStrategies4$outboundSchema),
+    ]),
+  ),
+});
+
+export function strategies4ToJSON(strategies4: Strategies4): string {
+  return JSON.stringify(Strategies4$outboundSchema.parse(strategies4));
+}
+export function strategies4FromJSON(
+  jsonString: string,
+): SafeParseResult<Strategies4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Strategies4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Strategies4' from JSON`,
+  );
+}
+
+/** @internal */
+export const Strategies3$inboundSchema: z.ZodType<
+  Strategies3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("none"),
+});
+/** @internal */
+export type Strategies3$Outbound = {
+  type: "none";
+};
+
+/** @internal */
+export const Strategies3$outboundSchema: z.ZodType<
+  Strategies3$Outbound,
+  z.ZodTypeDef,
+  Strategies3
+> = z.object({
+  type: z.literal("none"),
+});
+
+export function strategies3ToJSON(strategies3: Strategies3): string {
+  return JSON.stringify(Strategies3$outboundSchema.parse(strategies3));
+}
+export function strategies3FromJSON(
+  jsonString: string,
+): SafeParseResult<Strategies3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Strategies3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Strategies3' from JSON`,
+  );
+}
+
+/** @internal */
+export const Strategies2$inboundSchema: z.ZodType<
+  Strategies2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("custom-headers"),
+  headers: z.record(z.string()),
+  envVars: z.record(z.string()).optional(),
+});
+/** @internal */
+export type Strategies2$Outbound = {
+  type: "custom-headers";
+  headers: { [k: string]: string };
+  envVars?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const Strategies2$outboundSchema: z.ZodType<
+  Strategies2$Outbound,
+  z.ZodTypeDef,
+  Strategies2
+> = z.object({
+  type: z.literal("custom-headers"),
+  headers: z.record(z.string()),
+  envVars: z.record(z.string()).optional(),
+});
+
+export function strategies2ToJSON(strategies2: Strategies2): string {
+  return JSON.stringify(Strategies2$outboundSchema.parse(strategies2));
+}
+export function strategies2FromJSON(
+  jsonString: string,
+): SafeParseResult<Strategies2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Strategies2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Strategies2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Strategies1$inboundSchema: z.ZodType<
+  Strategies1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("api-key"),
+  value: z.string().optional(),
+  envVar: z.string().optional(),
+  headerName: z.string().optional(),
+});
+/** @internal */
+export type Strategies1$Outbound = {
+  type: "api-key";
+  value?: string | undefined;
+  envVar?: string | undefined;
+  headerName?: string | undefined;
+};
+
+/** @internal */
+export const Strategies1$outboundSchema: z.ZodType<
+  Strategies1$Outbound,
+  z.ZodTypeDef,
+  Strategies1
+> = z.object({
+  type: z.literal("api-key"),
+  value: z.string().optional(),
+  envVar: z.string().optional(),
+  headerName: z.string().optional(),
+});
+
+export function strategies1ToJSON(strategies1: Strategies1): string {
+  return JSON.stringify(Strategies1$outboundSchema.parse(strategies1));
+}
+export function strategies1FromJSON(
+  jsonString: string,
+): SafeParseResult<Strategies1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Strategies1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Strategies1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Strategies$inboundSchema: z.ZodType<
+  Strategies,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => Strategies1$inboundSchema),
+  z.lazy(() => Strategies2$inboundSchema),
+  z.lazy(() => Strategies3$inboundSchema),
+  z.lazy(() => Strategies4$inboundSchema),
+]);
+/** @internal */
+export type Strategies$Outbound =
+  | Strategies1$Outbound
+  | Strategies2$Outbound
+  | Strategies3$Outbound
+  | Strategies4$Outbound;
+
+/** @internal */
+export const Strategies$outboundSchema: z.ZodType<
+  Strategies$Outbound,
+  z.ZodTypeDef,
+  Strategies
+> = z.union([
+  z.lazy(() => Strategies1$outboundSchema),
+  z.lazy(() => Strategies2$outboundSchema),
+  z.lazy(() => Strategies3$outboundSchema),
+  z.lazy(() => Strategies4$outboundSchema),
+]);
+
+export function strategiesToJSON(strategies: Strategies): string {
+  return JSON.stringify(Strategies$outboundSchema.parse(strategies));
+}
+export function strategiesFromJSON(
+  jsonString: string,
+): SafeParseResult<Strategies, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Strategies$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Strategies' from JSON`,
+  );
+}
+
+/** @internal */
+export const Auth4$inboundSchema: z.ZodType<Auth4, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("composite"),
+    strategies: z.array(
+      z.union([
+        z.lazy(() => Strategies1$inboundSchema),
+        z.lazy(() => Strategies2$inboundSchema),
+        z.lazy(() => Strategies3$inboundSchema),
+        z.lazy(() => Strategies4$inboundSchema),
+      ]),
+    ),
+  });
+/** @internal */
+export type Auth4$Outbound = {
+  type: "composite";
+  strategies: Array<
+    | Strategies1$Outbound
+    | Strategies2$Outbound
+    | Strategies3$Outbound
+    | Strategies4$Outbound
+  >;
+};
+
+/** @internal */
+export const Auth4$outboundSchema: z.ZodType<
+  Auth4$Outbound,
+  z.ZodTypeDef,
+  Auth4
+> = z.object({
+  type: z.literal("composite"),
+  strategies: z.array(
+    z.union([
+      z.lazy(() => Strategies1$outboundSchema),
+      z.lazy(() => Strategies2$outboundSchema),
+      z.lazy(() => Strategies3$outboundSchema),
+      z.lazy(() => Strategies4$outboundSchema),
+    ]),
+  ),
+});
+
+export function auth4ToJSON(auth4: Auth4): string {
+  return JSON.stringify(Auth4$outboundSchema.parse(auth4));
+}
+export function auth4FromJSON(
+  jsonString: string,
+): SafeParseResult<Auth4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Auth4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Auth4' from JSON`,
+  );
+}
+
+/** @internal */
+export const Auth3$inboundSchema: z.ZodType<Auth3, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("none"),
+  });
+/** @internal */
+export type Auth3$Outbound = {
+  type: "none";
+};
+
+/** @internal */
+export const Auth3$outboundSchema: z.ZodType<
+  Auth3$Outbound,
+  z.ZodTypeDef,
+  Auth3
+> = z.object({
+  type: z.literal("none"),
+});
+
+export function auth3ToJSON(auth3: Auth3): string {
+  return JSON.stringify(Auth3$outboundSchema.parse(auth3));
+}
+export function auth3FromJSON(
+  jsonString: string,
+): SafeParseResult<Auth3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Auth3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Auth3' from JSON`,
+  );
+}
+
+/** @internal */
+export const Auth2$inboundSchema: z.ZodType<Auth2, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("custom-headers"),
+    headers: z.record(z.string()),
+    envVars: z.record(z.string()).optional(),
+  });
+/** @internal */
+export type Auth2$Outbound = {
+  type: "custom-headers";
+  headers: { [k: string]: string };
+  envVars?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const Auth2$outboundSchema: z.ZodType<
+  Auth2$Outbound,
+  z.ZodTypeDef,
+  Auth2
+> = z.object({
+  type: z.literal("custom-headers"),
+  headers: z.record(z.string()),
+  envVars: z.record(z.string()).optional(),
+});
+
+export function auth2ToJSON(auth2: Auth2): string {
+  return JSON.stringify(Auth2$outboundSchema.parse(auth2));
+}
+export function auth2FromJSON(
+  jsonString: string,
+): SafeParseResult<Auth2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Auth2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Auth2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Auth1$inboundSchema: z.ZodType<Auth1, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("api-key"),
+    value: z.string().optional(),
+    envVar: z.string().optional(),
+    headerName: z.string().optional(),
+  });
+/** @internal */
+export type Auth1$Outbound = {
+  type: "api-key";
+  value?: string | undefined;
+  envVar?: string | undefined;
+  headerName?: string | undefined;
+};
+
+/** @internal */
+export const Auth1$outboundSchema: z.ZodType<
+  Auth1$Outbound,
+  z.ZodTypeDef,
+  Auth1
+> = z.object({
+  type: z.literal("api-key"),
+  value: z.string().optional(),
+  envVar: z.string().optional(),
+  headerName: z.string().optional(),
+});
+
+export function auth1ToJSON(auth1: Auth1): string {
+  return JSON.stringify(Auth1$outboundSchema.parse(auth1));
+}
+export function auth1FromJSON(
+  jsonString: string,
+): SafeParseResult<Auth1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Auth1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Auth1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Auth$inboundSchema: z.ZodType<Auth, z.ZodTypeDef, unknown> = z
+  .union([
+    z.lazy(() => Auth1$inboundSchema),
+    z.lazy(() => Auth2$inboundSchema),
+    z.lazy(() => Auth3$inboundSchema),
+    z.lazy(() => Auth4$inboundSchema),
+  ]);
+/** @internal */
+export type Auth$Outbound =
+  | Auth1$Outbound
+  | Auth2$Outbound
+  | Auth3$Outbound
+  | Auth4$Outbound;
+
+/** @internal */
+export const Auth$outboundSchema: z.ZodType<Auth$Outbound, z.ZodTypeDef, Auth> =
+  z.union([
+    z.lazy(() => Auth1$outboundSchema),
+    z.lazy(() => Auth2$outboundSchema),
+    z.lazy(() => Auth3$outboundSchema),
+    z.lazy(() => Auth4$outboundSchema),
+  ]);
+
+export function authToJSON(auth: Auth): string {
+  return JSON.stringify(Auth$outboundSchema.parse(auth));
+}
+export function authFromJSON(
+  jsonString: string,
+): SafeParseResult<Auth, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Auth$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Auth' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddCatalogModelRequestInput$inboundSchema: z.ZodNativeEnum<
+  typeof AddCatalogModelRequestInput
+> = z.nativeEnum(AddCatalogModelRequestInput);
+/** @internal */
+export const AddCatalogModelRequestInput$outboundSchema: z.ZodNativeEnum<
+  typeof AddCatalogModelRequestInput
+> = AddCatalogModelRequestInput$inboundSchema;
+
+/** @internal */
+export const AddCatalogModelRequestOutput$inboundSchema: z.ZodNativeEnum<
+  typeof AddCatalogModelRequestOutput
+> = z.nativeEnum(AddCatalogModelRequestOutput);
+/** @internal */
+export const AddCatalogModelRequestOutput$outboundSchema: z.ZodNativeEnum<
+  typeof AddCatalogModelRequestOutput
+> = AddCatalogModelRequestOutput$inboundSchema;
+
+/** @internal */
+export const AddCatalogModelRequestModalities$inboundSchema: z.ZodType<
+  AddCatalogModelRequestModalities,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input: z.array(AddCatalogModelRequestInput$inboundSchema),
+  output: z.array(AddCatalogModelRequestOutput$inboundSchema),
+});
+/** @internal */
+export type AddCatalogModelRequestModalities$Outbound = {
+  input: Array<string>;
+  output: Array<string>;
+};
+
+/** @internal */
+export const AddCatalogModelRequestModalities$outboundSchema: z.ZodType<
+  AddCatalogModelRequestModalities$Outbound,
+  z.ZodTypeDef,
+  AddCatalogModelRequestModalities
+> = z.object({
+  input: z.array(AddCatalogModelRequestInput$outboundSchema),
+  output: z.array(AddCatalogModelRequestOutput$outboundSchema),
+});
+
+export function addCatalogModelRequestModalitiesToJSON(
+  addCatalogModelRequestModalities: AddCatalogModelRequestModalities,
+): string {
+  return JSON.stringify(
+    AddCatalogModelRequestModalities$outboundSchema.parse(
+      addCatalogModelRequestModalities,
+    ),
+  );
+}
+export function addCatalogModelRequestModalitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<AddCatalogModelRequestModalities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddCatalogModelRequestModalities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddCatalogModelRequestModalities' from JSON`,
+  );
+}
+
+/** @internal */
+export const MaxImageResolution$inboundSchema: z.ZodType<
+  MaxImageResolution,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  maxWidth: z.number().int(),
+  maxHeight: z.number().int(),
+});
+/** @internal */
+export type MaxImageResolution$Outbound = {
+  maxWidth: number;
+  maxHeight: number;
+};
+
+/** @internal */
+export const MaxImageResolution$outboundSchema: z.ZodType<
+  MaxImageResolution$Outbound,
+  z.ZodTypeDef,
+  MaxImageResolution
+> = z.object({
+  maxWidth: z.number().int(),
+  maxHeight: z.number().int(),
+});
+
+export function maxImageResolutionToJSON(
+  maxImageResolution: MaxImageResolution,
+): string {
+  return JSON.stringify(
+    MaxImageResolution$outboundSchema.parse(maxImageResolution),
+  );
+}
+export function maxImageResolutionFromJSON(
+  jsonString: string,
+): SafeParseResult<MaxImageResolution, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MaxImageResolution$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MaxImageResolution' from JSON`,
+  );
+}
+
+/** @internal */
+export const MinImageResolution$inboundSchema: z.ZodType<
+  MinImageResolution,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  maxWidth: z.number().int(),
+  maxHeight: z.number().int(),
+});
+/** @internal */
+export type MinImageResolution$Outbound = {
+  maxWidth: number;
+  maxHeight: number;
+};
+
+/** @internal */
+export const MinImageResolution$outboundSchema: z.ZodType<
+  MinImageResolution$Outbound,
+  z.ZodTypeDef,
+  MinImageResolution
+> = z.object({
+  maxWidth: z.number().int(),
+  maxHeight: z.number().int(),
+});
+
+export function minImageResolutionToJSON(
+  minImageResolution: MinImageResolution,
+): string {
+  return JSON.stringify(
+    MinImageResolution$outboundSchema.parse(minImageResolution),
+  );
+}
+export function minImageResolutionFromJSON(
+  jsonString: string,
+): SafeParseResult<MinImageResolution, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MinImageResolution$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MinImageResolution' from JSON`,
+  );
+}
+
+/** @internal */
+export const Capabilities$inboundSchema: z.ZodType<
+  Capabilities,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  modalities: z.lazy(() => AddCatalogModelRequestModalities$inboundSchema),
+  reasoning: z.boolean(),
+  supportedBase64Formats: z.array(z.string()).optional(),
+  supportsCompletionVideoUrlMessage: z.boolean().optional(),
+  supportsTemperature: z.boolean().optional(),
+  supportsTopP: z.boolean().optional(),
+  maxImageResolution: z.lazy(() => MaxImageResolution$inboundSchema).optional(),
+  minImageResolution: z.lazy(() => MinImageResolution$inboundSchema).optional(),
+});
+/** @internal */
+export type Capabilities$Outbound = {
+  modalities: AddCatalogModelRequestModalities$Outbound;
+  reasoning: boolean;
+  supportedBase64Formats?: Array<string> | undefined;
+  supportsCompletionVideoUrlMessage?: boolean | undefined;
+  supportsTemperature?: boolean | undefined;
+  supportsTopP?: boolean | undefined;
+  maxImageResolution?: MaxImageResolution$Outbound | undefined;
+  minImageResolution?: MinImageResolution$Outbound | undefined;
+};
+
+/** @internal */
+export const Capabilities$outboundSchema: z.ZodType<
+  Capabilities$Outbound,
+  z.ZodTypeDef,
+  Capabilities
+> = z.object({
+  modalities: z.lazy(() => AddCatalogModelRequestModalities$outboundSchema),
+  reasoning: z.boolean(),
+  supportedBase64Formats: z.array(z.string()).optional(),
+  supportsCompletionVideoUrlMessage: z.boolean().optional(),
+  supportsTemperature: z.boolean().optional(),
+  supportsTopP: z.boolean().optional(),
+  maxImageResolution: z.lazy(() => MaxImageResolution$outboundSchema)
+    .optional(),
+  minImageResolution: z.lazy(() => MinImageResolution$outboundSchema)
+    .optional(),
+});
+
+export function capabilitiesToJSON(capabilities: Capabilities): string {
+  return JSON.stringify(Capabilities$outboundSchema.parse(capabilities));
+}
+export function capabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<Capabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Capabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Capabilities' from JSON`,
+  );
+}
+
+/** @internal */
+export const Scope$inboundSchema: z.ZodNativeEnum<typeof Scope> = z.nativeEnum(
+  Scope,
+);
+/** @internal */
+export const Scope$outboundSchema: z.ZodNativeEnum<typeof Scope> =
+  Scope$inboundSchema;
+
+/** @internal */
+export const Queue$inboundSchema: z.ZodType<Queue, z.ZodTypeDef, unknown> = z
+  .object({
+    maxDepth: z.number().int(),
+    maxWaitMs: z.number().int(),
+  });
+/** @internal */
+export type Queue$Outbound = {
+  maxDepth: number;
+  maxWaitMs: number;
+};
+
+/** @internal */
+export const Queue$outboundSchema: z.ZodType<
+  Queue$Outbound,
+  z.ZodTypeDef,
+  Queue
+> = z.object({
+  maxDepth: z.number().int(),
+  maxWaitMs: z.number().int(),
+});
+
+export function queueToJSON(queue: Queue): string {
+  return JSON.stringify(Queue$outboundSchema.parse(queue));
+}
+export function queueFromJSON(
+  jsonString: string,
+): SafeParseResult<Queue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Queue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Queue' from JSON`,
+  );
+}
+
+/** @internal */
+export const RateLimits$inboundSchema: z.ZodType<
+  RateLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  scope: Scope$inboundSchema,
+  rpm: z.number().int(),
+  duration: z.number().int().optional(),
+  queue: z.lazy(() => Queue$inboundSchema).optional(),
+});
+/** @internal */
+export type RateLimits$Outbound = {
+  scope: string;
+  rpm: number;
+  duration?: number | undefined;
+  queue?: Queue$Outbound | undefined;
+};
+
+/** @internal */
+export const RateLimits$outboundSchema: z.ZodType<
+  RateLimits$Outbound,
+  z.ZodTypeDef,
+  RateLimits
+> = z.object({
+  scope: Scope$outboundSchema,
+  rpm: z.number().int(),
+  duration: z.number().int().optional(),
+  queue: z.lazy(() => Queue$outboundSchema).optional(),
+});
+
+export function rateLimitsToJSON(rateLimits: RateLimits): string {
+  return JSON.stringify(RateLimits$outboundSchema.parse(rateLimits));
+}
+export function rateLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<RateLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RateLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RateLimits' from JSON`,
+  );
+}
+
+/** @internal */
+export const Concurrency$inboundSchema: z.ZodType<
+  Concurrency,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  max: z.number().int(),
+  maxWaitMs: z.number().int().optional(),
+});
+/** @internal */
+export type Concurrency$Outbound = {
+  max: number;
+  maxWaitMs?: number | undefined;
+};
+
+/** @internal */
+export const Concurrency$outboundSchema: z.ZodType<
+  Concurrency$Outbound,
+  z.ZodTypeDef,
+  Concurrency
+> = z.object({
+  max: z.number().int(),
+  maxWaitMs: z.number().int().optional(),
+});
+
+export function concurrencyToJSON(concurrency: Concurrency): string {
+  return JSON.stringify(Concurrency$outboundSchema.parse(concurrency));
+}
+export function concurrencyFromJSON(
+  jsonString: string,
+): SafeParseResult<Concurrency, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Concurrency$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Concurrency' from JSON`,
+  );
+}
+
+/** @internal */
+export const DefaultParams$inboundSchema: z.ZodType<
+  DefaultParams,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  temperature: z.number().optional(),
+  topP: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+});
+/** @internal */
+export type DefaultParams$Outbound = {
+  temperature?: number | undefined;
+  topP?: number | undefined;
+  presencePenalty?: number | undefined;
+  frequencyPenalty?: number | undefined;
+};
+
+/** @internal */
+export const DefaultParams$outboundSchema: z.ZodType<
+  DefaultParams$Outbound,
+  z.ZodTypeDef,
+  DefaultParams
+> = z.object({
+  temperature: z.number().optional(),
+  topP: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+});
+
+export function defaultParamsToJSON(defaultParams: DefaultParams): string {
+  return JSON.stringify(DefaultParams$outboundSchema.parse(defaultParams));
+}
+export function defaultParamsFromJSON(
+  jsonString: string,
+): SafeParseResult<DefaultParams, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DefaultParams$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DefaultParams' from JSON`,
+  );
+}
+
+/** @internal */
+export const Trigger4$inboundSchema: z.ZodType<
+  Trigger4,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("error-fallback"),
+});
+/** @internal */
+export type Trigger4$Outbound = {
+  type: "error-fallback";
+};
+
+/** @internal */
+export const Trigger4$outboundSchema: z.ZodType<
+  Trigger4$Outbound,
+  z.ZodTypeDef,
+  Trigger4
+> = z.object({
+  type: z.literal("error-fallback"),
+});
+
+export function trigger4ToJSON(trigger4: Trigger4): string {
+  return JSON.stringify(Trigger4$outboundSchema.parse(trigger4));
+}
+export function trigger4FromJSON(
+  jsonString: string,
+): SafeParseResult<Trigger4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Trigger4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Trigger4' from JSON`,
+  );
+}
+
+/** @internal */
+export const Trigger3$inboundSchema: z.ZodType<
+  Trigger3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("context-exceeded"),
+});
+/** @internal */
+export type Trigger3$Outbound = {
+  type: "context-exceeded";
+};
+
+/** @internal */
+export const Trigger3$outboundSchema: z.ZodType<
+  Trigger3$Outbound,
+  z.ZodTypeDef,
+  Trigger3
+> = z.object({
+  type: z.literal("context-exceeded"),
+});
+
+export function trigger3ToJSON(trigger3: Trigger3): string {
+  return JSON.stringify(Trigger3$outboundSchema.parse(trigger3));
+}
+export function trigger3FromJSON(
+  jsonString: string,
+): SafeParseResult<Trigger3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Trigger3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Trigger3' from JSON`,
+  );
+}
+
+/** @internal */
+export const Trigger2$inboundSchema: z.ZodType<
+  Trigger2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("base64-input"),
+});
+/** @internal */
+export type Trigger2$Outbound = {
+  type: "base64-input";
+};
+
+/** @internal */
+export const Trigger2$outboundSchema: z.ZodType<
+  Trigger2$Outbound,
+  z.ZodTypeDef,
+  Trigger2
+> = z.object({
+  type: z.literal("base64-input"),
+});
+
+export function trigger2ToJSON(trigger2: Trigger2): string {
+  return JSON.stringify(Trigger2$outboundSchema.parse(trigger2));
+}
+export function trigger2FromJSON(
+  jsonString: string,
+): SafeParseResult<Trigger2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Trigger2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Trigger2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Modality$inboundSchema: z.ZodNativeEnum<typeof Modality> = z
+  .nativeEnum(Modality);
+/** @internal */
+export const Modality$outboundSchema: z.ZodNativeEnum<typeof Modality> =
+  Modality$inboundSchema;
+
+/** @internal */
+export const Trigger1$inboundSchema: z.ZodType<
+  Trigger1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("input-modality"),
+  modality: Modality$inboundSchema,
+});
+/** @internal */
+export type Trigger1$Outbound = {
+  type: "input-modality";
+  modality: string;
+};
+
+/** @internal */
+export const Trigger1$outboundSchema: z.ZodType<
+  Trigger1$Outbound,
+  z.ZodTypeDef,
+  Trigger1
+> = z.object({
+  type: z.literal("input-modality"),
+  modality: Modality$outboundSchema,
+});
+
+export function trigger1ToJSON(trigger1: Trigger1): string {
+  return JSON.stringify(Trigger1$outboundSchema.parse(trigger1));
+}
+export function trigger1FromJSON(
+  jsonString: string,
+): SafeParseResult<Trigger1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Trigger1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Trigger1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Trigger$inboundSchema: z.ZodType<Trigger, z.ZodTypeDef, unknown> =
+  z.union([
+    z.lazy(() => Trigger1$inboundSchema),
+    z.lazy(() => Trigger2$inboundSchema),
+    z.lazy(() => Trigger3$inboundSchema),
+    z.lazy(() => Trigger4$inboundSchema),
+  ]);
+/** @internal */
+export type Trigger$Outbound =
+  | Trigger1$Outbound
+  | Trigger2$Outbound
+  | Trigger3$Outbound
+  | Trigger4$Outbound;
+
+/** @internal */
+export const Trigger$outboundSchema: z.ZodType<
+  Trigger$Outbound,
+  z.ZodTypeDef,
+  Trigger
+> = z.union([
+  z.lazy(() => Trigger1$outboundSchema),
+  z.lazy(() => Trigger2$outboundSchema),
+  z.lazy(() => Trigger3$outboundSchema),
+  z.lazy(() => Trigger4$outboundSchema),
+]);
+
+export function triggerToJSON(trigger: Trigger): string {
+  return JSON.stringify(Trigger$outboundSchema.parse(trigger));
+}
+export function triggerFromJSON(
+  jsonString: string,
+): SafeParseResult<Trigger, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Trigger$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Trigger' from JSON`,
+  );
+}
+
+/** @internal */
+export const RerouteRules$inboundSchema: z.ZodType<
+  RerouteRules,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  trigger: z.union([
+    z.lazy(() => Trigger1$inboundSchema),
+    z.lazy(() => Trigger2$inboundSchema),
+    z.lazy(() => Trigger3$inboundSchema),
+    z.lazy(() => Trigger4$inboundSchema),
+  ]),
+  targetModelId: z.string(),
+  preserveParams: z.boolean().optional(),
+  log: z.boolean().optional(),
+});
+/** @internal */
+export type RerouteRules$Outbound = {
+  trigger:
+    | Trigger1$Outbound
+    | Trigger2$Outbound
+    | Trigger3$Outbound
+    | Trigger4$Outbound;
+  targetModelId: string;
+  preserveParams?: boolean | undefined;
+  log?: boolean | undefined;
+};
+
+/** @internal */
+export const RerouteRules$outboundSchema: z.ZodType<
+  RerouteRules$Outbound,
+  z.ZodTypeDef,
+  RerouteRules
+> = z.object({
+  trigger: z.union([
+    z.lazy(() => Trigger1$outboundSchema),
+    z.lazy(() => Trigger2$outboundSchema),
+    z.lazy(() => Trigger3$outboundSchema),
+    z.lazy(() => Trigger4$outboundSchema),
+  ]),
+  targetModelId: z.string(),
+  preserveParams: z.boolean().optional(),
+  log: z.boolean().optional(),
+});
+
+export function rerouteRulesToJSON(rerouteRules: RerouteRules): string {
+  return JSON.stringify(RerouteRules$outboundSchema.parse(rerouteRules));
+}
+export function rerouteRulesFromJSON(
+  jsonString: string,
+): SafeParseResult<RerouteRules, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RerouteRules$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RerouteRules' from JSON`,
+  );
+}
+
+/** @internal */
+export const Dimensions2$inboundSchema: z.ZodType<
+  Dimensions2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  min: z.number().int(),
+  max: z.number().int(),
+  default: z.number().int(),
+});
+/** @internal */
+export type Dimensions2$Outbound = {
+  min: number;
+  max: number;
+  default: number;
+};
+
+/** @internal */
+export const Dimensions2$outboundSchema: z.ZodType<
+  Dimensions2$Outbound,
+  z.ZodTypeDef,
+  Dimensions2
+> = z.object({
+  min: z.number().int(),
+  max: z.number().int(),
+  default: z.number().int(),
+});
+
+export function dimensions2ToJSON(dimensions2: Dimensions2): string {
+  return JSON.stringify(Dimensions2$outboundSchema.parse(dimensions2));
+}
+export function dimensions2FromJSON(
+  jsonString: string,
+): SafeParseResult<Dimensions2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Dimensions2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Dimensions2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Dimensions$inboundSchema: z.ZodType<
+  Dimensions,
+  z.ZodTypeDef,
+  unknown
+> = z.union([z.lazy(() => Dimensions2$inboundSchema), z.number().int()]);
+/** @internal */
+export type Dimensions$Outbound = Dimensions2$Outbound | number;
+
+/** @internal */
+export const Dimensions$outboundSchema: z.ZodType<
+  Dimensions$Outbound,
+  z.ZodTypeDef,
+  Dimensions
+> = z.union([z.lazy(() => Dimensions2$outboundSchema), z.number().int()]);
+
+export function dimensionsToJSON(dimensions: Dimensions): string {
+  return JSON.stringify(Dimensions$outboundSchema.parse(dimensions));
+}
+export function dimensionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Dimensions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Dimensions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Dimensions' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmbeddingLimits$inboundSchema: z.ZodType<
+  EmbeddingLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  maxBatchSize: z.number().int().optional(),
+  dimensions: z.union([
+    z.lazy(() => Dimensions2$inboundSchema),
+    z.number().int(),
+  ]).optional(),
+});
+/** @internal */
+export type EmbeddingLimits$Outbound = {
+  maxBatchSize?: number | undefined;
+  dimensions?: Dimensions2$Outbound | number | undefined;
+};
+
+/** @internal */
+export const EmbeddingLimits$outboundSchema: z.ZodType<
+  EmbeddingLimits$Outbound,
+  z.ZodTypeDef,
+  EmbeddingLimits
+> = z.object({
+  maxBatchSize: z.number().int().optional(),
+  dimensions: z.union([
+    z.lazy(() => Dimensions2$outboundSchema),
+    z.number().int(),
+  ]).optional(),
+});
+
+export function embeddingLimitsToJSON(
+  embeddingLimits: EmbeddingLimits,
+): string {
+  return JSON.stringify(EmbeddingLimits$outboundSchema.parse(embeddingLimits));
+}
+export function embeddingLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<EmbeddingLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmbeddingLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmbeddingLimits' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddCatalogModelRequestHealthCheckMethod$inboundSchema:
+  z.ZodNativeEnum<typeof AddCatalogModelRequestHealthCheckMethod> = z
+    .nativeEnum(AddCatalogModelRequestHealthCheckMethod);
+/** @internal */
+export const AddCatalogModelRequestHealthCheckMethod$outboundSchema:
+  z.ZodNativeEnum<typeof AddCatalogModelRequestHealthCheckMethod> =
+    AddCatalogModelRequestHealthCheckMethod$inboundSchema;
+
+/** @internal */
+export const HealthCheck3$inboundSchema: z.ZodType<
+  HealthCheck3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: z.literal("periodic"),
+  intervalSeconds: z.number().int(),
+  path: z.string(),
+  method: AddCatalogModelRequestHealthCheckMethod$inboundSchema.optional(),
+  timeoutMs: z.number().int().optional(),
+  cacheTtlSeconds: z.number().int().optional(),
+});
+/** @internal */
+export type HealthCheck3$Outbound = {
+  mode: "periodic";
+  intervalSeconds: number;
+  path: string;
+  method?: string | undefined;
+  timeoutMs?: number | undefined;
+  cacheTtlSeconds?: number | undefined;
+};
+
+/** @internal */
+export const HealthCheck3$outboundSchema: z.ZodType<
+  HealthCheck3$Outbound,
+  z.ZodTypeDef,
+  HealthCheck3
+> = z.object({
+  mode: z.literal("periodic"),
+  intervalSeconds: z.number().int(),
+  path: z.string(),
+  method: AddCatalogModelRequestHealthCheckMethod$outboundSchema.optional(),
+  timeoutMs: z.number().int().optional(),
+  cacheTtlSeconds: z.number().int().optional(),
+});
+
+export function healthCheck3ToJSON(healthCheck3: HealthCheck3): string {
+  return JSON.stringify(HealthCheck3$outboundSchema.parse(healthCheck3));
+}
+export function healthCheck3FromJSON(
+  jsonString: string,
+): SafeParseResult<HealthCheck3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HealthCheck3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HealthCheck3' from JSON`,
+  );
+}
+
+/** @internal */
+export const HealthCheckMethod$inboundSchema: z.ZodNativeEnum<
+  typeof HealthCheckMethod
+> = z.nativeEnum(HealthCheckMethod);
+/** @internal */
+export const HealthCheckMethod$outboundSchema: z.ZodNativeEnum<
+  typeof HealthCheckMethod
+> = HealthCheckMethod$inboundSchema;
+
+/** @internal */
+export const HealthCheck2$inboundSchema: z.ZodType<
+  HealthCheck2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: z.literal("preflight"),
+  path: z.string(),
+  method: HealthCheckMethod$inboundSchema.optional(),
+  timeoutMs: z.number().int().optional(),
+  cacheTtlSeconds: z.number().int().optional(),
+});
+/** @internal */
+export type HealthCheck2$Outbound = {
+  mode: "preflight";
+  path: string;
+  method?: string | undefined;
+  timeoutMs?: number | undefined;
+  cacheTtlSeconds?: number | undefined;
+};
+
+/** @internal */
+export const HealthCheck2$outboundSchema: z.ZodType<
+  HealthCheck2$Outbound,
+  z.ZodTypeDef,
+  HealthCheck2
+> = z.object({
+  mode: z.literal("preflight"),
+  path: z.string(),
+  method: HealthCheckMethod$outboundSchema.optional(),
+  timeoutMs: z.number().int().optional(),
+  cacheTtlSeconds: z.number().int().optional(),
+});
+
+export function healthCheck2ToJSON(healthCheck2: HealthCheck2): string {
+  return JSON.stringify(HealthCheck2$outboundSchema.parse(healthCheck2));
+}
+export function healthCheck2FromJSON(
+  jsonString: string,
+): SafeParseResult<HealthCheck2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HealthCheck2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HealthCheck2' from JSON`,
+  );
+}
+
+/** @internal */
+export const HealthCheck1$inboundSchema: z.ZodType<
+  HealthCheck1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: z.literal("off"),
+});
+/** @internal */
+export type HealthCheck1$Outbound = {
+  mode: "off";
+};
+
+/** @internal */
+export const HealthCheck1$outboundSchema: z.ZodType<
+  HealthCheck1$Outbound,
+  z.ZodTypeDef,
+  HealthCheck1
+> = z.object({
+  mode: z.literal("off"),
+});
+
+export function healthCheck1ToJSON(healthCheck1: HealthCheck1): string {
+  return JSON.stringify(HealthCheck1$outboundSchema.parse(healthCheck1));
+}
+export function healthCheck1FromJSON(
+  jsonString: string,
+): SafeParseResult<HealthCheck1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HealthCheck1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HealthCheck1' from JSON`,
+  );
+}
+
+/** @internal */
+export const HealthCheck$inboundSchema: z.ZodType<
+  HealthCheck,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => HealthCheck1$inboundSchema),
+  z.lazy(() => HealthCheck2$inboundSchema),
+  z.lazy(() => HealthCheck3$inboundSchema),
+]);
+/** @internal */
+export type HealthCheck$Outbound =
+  | HealthCheck1$Outbound
+  | HealthCheck2$Outbound
+  | HealthCheck3$Outbound;
+
+/** @internal */
+export const HealthCheck$outboundSchema: z.ZodType<
+  HealthCheck$Outbound,
+  z.ZodTypeDef,
+  HealthCheck
+> = z.union([
+  z.lazy(() => HealthCheck1$outboundSchema),
+  z.lazy(() => HealthCheck2$outboundSchema),
+  z.lazy(() => HealthCheck3$outboundSchema),
+]);
+
+export function healthCheckToJSON(healthCheck: HealthCheck): string {
+  return JSON.stringify(HealthCheck$outboundSchema.parse(healthCheck));
+}
+export function healthCheckFromJSON(
+  jsonString: string,
+): SafeParseResult<HealthCheck, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HealthCheck$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HealthCheck' from JSON`,
+  );
+}
+
+/** @internal */
+export const AddCatalogModelRequest$inboundSchema: z.ZodType<
+  AddCatalogModelRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  provider: z.string(),
+  modelId: z.string(),
+  displayName: z.string().optional(),
+  baseUrl: z.string().optional(),
+  apiFormat: AutoEndpoint$inboundSchema,
+  apiProviderType: ApiProviderType$inboundSchema,
+  created: z.number().int(),
+  auth: z.union([
+    z.lazy(() => Auth1$inboundSchema),
+    z.lazy(() => Auth2$inboundSchema),
+    z.lazy(() => Auth3$inboundSchema),
+    z.lazy(() => Auth4$inboundSchema),
+  ]),
+  capabilities: z.lazy(() => Capabilities$inboundSchema),
+  contextWindow: z.number().int().optional(),
+  rpm: z.number().int().optional(),
+  rateLimits: z.array(z.lazy(() => RateLimits$inboundSchema)).optional(),
+  concurrency: z.lazy(() => Concurrency$inboundSchema).optional(),
+  requestTimeoutMs: z.number().int().optional(),
+  maxRetries: z.number().int().optional(),
+  defaultParams: z.lazy(() => DefaultParams$inboundSchema).optional(),
+  rerouteRules: z.array(z.lazy(() => RerouteRules$inboundSchema)).optional(),
+  hidden: z.boolean().optional(),
+  embeddingLimits: z.lazy(() => EmbeddingLimits$inboundSchema).optional(),
+  healthCheck: z.union([
+    z.lazy(() => HealthCheck1$inboundSchema),
+    z.lazy(() => HealthCheck2$inboundSchema),
+    z.lazy(() => HealthCheck3$inboundSchema),
+  ]).optional(),
+});
+/** @internal */
+export type AddCatalogModelRequest$Outbound = {
+  id: string;
+  provider: string;
+  modelId: string;
+  displayName?: string | undefined;
+  baseUrl?: string | undefined;
+  apiFormat: string;
+  apiProviderType: string;
+  created: number;
+  auth: Auth1$Outbound | Auth2$Outbound | Auth3$Outbound | Auth4$Outbound;
+  capabilities: Capabilities$Outbound;
+  contextWindow?: number | undefined;
+  rpm?: number | undefined;
+  rateLimits?: Array<RateLimits$Outbound> | undefined;
+  concurrency?: Concurrency$Outbound | undefined;
+  requestTimeoutMs?: number | undefined;
+  maxRetries?: number | undefined;
+  defaultParams?: DefaultParams$Outbound | undefined;
+  rerouteRules?: Array<RerouteRules$Outbound> | undefined;
+  hidden?: boolean | undefined;
+  embeddingLimits?: EmbeddingLimits$Outbound | undefined;
+  healthCheck?:
+    | HealthCheck1$Outbound
+    | HealthCheck2$Outbound
+    | HealthCheck3$Outbound
+    | undefined;
+};
+
+/** @internal */
+export const AddCatalogModelRequest$outboundSchema: z.ZodType<
+  AddCatalogModelRequest$Outbound,
+  z.ZodTypeDef,
+  AddCatalogModelRequest
+> = z.object({
+  id: z.string(),
+  provider: z.string(),
+  modelId: z.string(),
+  displayName: z.string().optional(),
+  baseUrl: z.string().optional(),
+  apiFormat: AutoEndpoint$outboundSchema,
+  apiProviderType: ApiProviderType$outboundSchema,
+  created: z.number().int(),
+  auth: z.union([
+    z.lazy(() => Auth1$outboundSchema),
+    z.lazy(() => Auth2$outboundSchema),
+    z.lazy(() => Auth3$outboundSchema),
+    z.lazy(() => Auth4$outboundSchema),
+  ]),
+  capabilities: z.lazy(() => Capabilities$outboundSchema),
+  contextWindow: z.number().int().optional(),
+  rpm: z.number().int().optional(),
+  rateLimits: z.array(z.lazy(() => RateLimits$outboundSchema)).optional(),
+  concurrency: z.lazy(() => Concurrency$outboundSchema).optional(),
+  requestTimeoutMs: z.number().int().optional(),
+  maxRetries: z.number().int().optional(),
+  defaultParams: z.lazy(() => DefaultParams$outboundSchema).optional(),
+  rerouteRules: z.array(z.lazy(() => RerouteRules$outboundSchema)).optional(),
+  hidden: z.boolean().optional(),
+  embeddingLimits: z.lazy(() => EmbeddingLimits$outboundSchema).optional(),
+  healthCheck: z.union([
+    z.lazy(() => HealthCheck1$outboundSchema),
+    z.lazy(() => HealthCheck2$outboundSchema),
+    z.lazy(() => HealthCheck3$outboundSchema),
+  ]).optional(),
+});
+
+export function addCatalogModelRequestToJSON(
+  addCatalogModelRequest: AddCatalogModelRequest,
+): string {
+  return JSON.stringify(
+    AddCatalogModelRequest$outboundSchema.parse(addCatalogModelRequest),
+  );
+}
+export function addCatalogModelRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AddCatalogModelRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddCatalogModelRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddCatalogModelRequest' from JSON`,
+  );
+}