/*
 * 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`,
  );
}