/*
 * 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 UpdateCatalogModelRequestApiProviderType = {
  Groq: "groq",
  Azure: "azure",
  Meetkai: "meetkai",
  MeetkaiGateway: "meetkaiGateway",
  Fal: "fal",
  Openai: "openai",
} as const;
export type UpdateCatalogModelRequestApiProviderType = ClosedEnum<
  typeof UpdateCatalogModelRequestApiProviderType
>;

export type UpdateCatalogModelRequestStrategiesAuth4 = {
  type: "composite";
  strategies?: any | undefined;
};

export type UpdateCatalogModelRequestStrategiesAuth3 = {
  type: "none";
};

export type UpdateCatalogModelRequestStrategiesAuth2 = {
  type: "custom-headers";
  headers: { [k: string]: string };
  envVars?: { [k: string]: string } | undefined;
};

export type UpdateCatalogModelRequestStrategiesAuth1 = {
  type: "api-key";
  value?: string | undefined;
  envVar?: string | undefined;
  headerName?: string | undefined;
};

export type UpdateCatalogModelRequestStrategiesStrategies =
  | UpdateCatalogModelRequestStrategiesAuth1
  | UpdateCatalogModelRequestStrategiesAuth2
  | UpdateCatalogModelRequestStrategiesAuth3
  | UpdateCatalogModelRequestStrategiesAuth4;

export type UpdateCatalogModelRequestStrategies4 = {
  type: "composite";
  strategies: Array<
    | UpdateCatalogModelRequestStrategiesAuth1
    | UpdateCatalogModelRequestStrategiesAuth2
    | UpdateCatalogModelRequestStrategiesAuth3
    | UpdateCatalogModelRequestStrategiesAuth4
  >;
};

export type UpdateCatalogModelRequestStrategies3 = {
  type: "none";
};

export type UpdateCatalogModelRequestStrategies2 = {
  type: "custom-headers";
  headers: { [k: string]: string };
  envVars?: { [k: string]: string } | undefined;
};

export type UpdateCatalogModelRequestStrategies1 = {
  type: "api-key";
  value?: string | undefined;
  envVar?: string | undefined;
  headerName?: string | undefined;
};

export type AuthStrategies =
  | UpdateCatalogModelRequestStrategies1
  | UpdateCatalogModelRequestStrategies2
  | UpdateCatalogModelRequestStrategies3
  | UpdateCatalogModelRequestStrategies4;

export type UpdateCatalogModelRequestAuth4 = {
  type: "composite";
  strategies: Array<
    | UpdateCatalogModelRequestStrategies1
    | UpdateCatalogModelRequestStrategies2
    | UpdateCatalogModelRequestStrategies3
    | UpdateCatalogModelRequestStrategies4
  >;
};

export type UpdateCatalogModelRequestAuth3 = {
  type: "none";
};

export type UpdateCatalogModelRequestAuth2 = {
  type: "custom-headers";
  headers: { [k: string]: string };
  envVars?: { [k: string]: string } | undefined;
};

export type UpdateCatalogModelRequestAuth1 = {
  type: "api-key";
  value?: string | undefined;
  envVar?: string | undefined;
  headerName?: string | undefined;
};

export type UpdateCatalogModelRequestAuth =
  | UpdateCatalogModelRequestAuth1
  | UpdateCatalogModelRequestAuth2
  | UpdateCatalogModelRequestAuth3
  | UpdateCatalogModelRequestAuth4;

export const UpdateCatalogModelRequestInput = {
  Text: "text",
  Image: "image",
  Audio: "audio",
  Video: "video",
} as const;
export type UpdateCatalogModelRequestInput = ClosedEnum<
  typeof UpdateCatalogModelRequestInput
>;

export const UpdateCatalogModelRequestOutput = {
  Text: "text",
  Image: "image",
  Audio: "audio",
  Video: "video",
} as const;
export type UpdateCatalogModelRequestOutput = ClosedEnum<
  typeof UpdateCatalogModelRequestOutput
>;

export type UpdateCatalogModelRequestModalities = {
  input: Array<UpdateCatalogModelRequestInput>;
  output: Array<UpdateCatalogModelRequestOutput>;
};

export type UpdateCatalogModelRequestMaxImageResolution = {
  maxWidth: number;
  maxHeight: number;
};

export type UpdateCatalogModelRequestMinImageResolution = {
  maxWidth: number;
  maxHeight: number;
};

export type UpdateCatalogModelRequestCapabilities = {
  modalities: UpdateCatalogModelRequestModalities;
  reasoning: boolean;
  supportedBase64Formats?: Array<string> | undefined;
  supportsCompletionVideoUrlMessage?: boolean | undefined;
  supportsTemperature?: boolean | undefined;
  supportsTopP?: boolean | undefined;
  maxImageResolution?: UpdateCatalogModelRequestMaxImageResolution | undefined;
  minImageResolution?: UpdateCatalogModelRequestMinImageResolution | undefined;
};

export const RateLimitsScope = {
  Global: "global",
  Org: "org",
  User: "user",
  ApiKey: "apiKey",
  ExternalUser: "externalUser",
} as const;
export type RateLimitsScope = ClosedEnum<typeof RateLimitsScope>;

export type RateLimitsQueue = {
  maxDepth: number;
  maxWaitMs: number;
};

export type UpdateCatalogModelRequestRateLimits = {
  scope: RateLimitsScope;
  rpm: number;
  duration?: number | undefined;
  queue?: RateLimitsQueue | undefined;
};

export type UpdateCatalogModelRequestConcurrency = {
  max: number;
  maxWaitMs?: number | undefined;
};

export type UpdateCatalogModelRequestDefaultParams = {
  temperature?: number | undefined;
  topP?: number | undefined;
  presencePenalty?: number | undefined;
  frequencyPenalty?: number | undefined;
};

export type UpdateCatalogModelRequestTrigger4 = {
  type: "error-fallback";
};

export type UpdateCatalogModelRequestTrigger3 = {
  type: "context-exceeded";
};

export type UpdateCatalogModelRequestTrigger2 = {
  type: "base64-input";
};

export const TriggerModality = {
  Text: "text",
  Image: "image",
  Audio: "audio",
  Video: "video",
} as const;
export type TriggerModality = ClosedEnum<typeof TriggerModality>;

export type UpdateCatalogModelRequestTrigger1 = {
  type: "input-modality";
  modality: TriggerModality;
};

export type RerouteRulesTrigger =
  | UpdateCatalogModelRequestTrigger1
  | UpdateCatalogModelRequestTrigger2
  | UpdateCatalogModelRequestTrigger3
  | UpdateCatalogModelRequestTrigger4;

export type UpdateCatalogModelRequestRerouteRules = {
  trigger:
    | UpdateCatalogModelRequestTrigger1
    | UpdateCatalogModelRequestTrigger2
    | UpdateCatalogModelRequestTrigger3
    | UpdateCatalogModelRequestTrigger4;
  targetModelId: string;
  preserveParams?: boolean | undefined;
  log?: boolean | undefined;
};

export type UpdateCatalogModelRequestDimensions2 = {
  min: number;
  max: number;
  default: number;
};

export type EmbeddingLimitsDimensions =
  | UpdateCatalogModelRequestDimensions2
  | number;

export type UpdateCatalogModelRequestEmbeddingLimits = {
  maxBatchSize?: number | undefined;
  dimensions?: UpdateCatalogModelRequestDimensions2 | number | undefined;
};

export const UpdateCatalogModelRequestHealthCheck3Method = {
  Get: "GET",
  Head: "HEAD",
} as const;
export type UpdateCatalogModelRequestHealthCheck3Method = ClosedEnum<
  typeof UpdateCatalogModelRequestHealthCheck3Method
>;

export type UpdateCatalogModelRequestHealthCheck3 = {
  mode: "periodic";
  intervalSeconds: number;
  path: string;
  method?: UpdateCatalogModelRequestHealthCheck3Method | undefined;
  timeoutMs?: number | undefined;
  cacheTtlSeconds?: number | undefined;
};

export const UpdateCatalogModelRequestHealthCheckMethod = {
  Get: "GET",
  Head: "HEAD",
} as const;
export type UpdateCatalogModelRequestHealthCheckMethod = ClosedEnum<
  typeof UpdateCatalogModelRequestHealthCheckMethod
>;

export type UpdateCatalogModelRequestHealthCheck2 = {
  mode: "preflight";
  path: string;
  method?: UpdateCatalogModelRequestHealthCheckMethod | undefined;
  timeoutMs?: number | undefined;
  cacheTtlSeconds?: number | undefined;
};

export type UpdateCatalogModelRequestHealthCheck1 = {
  mode: "off";
};

export type UpdateCatalogModelRequestHealthCheck =
  | UpdateCatalogModelRequestHealthCheck1
  | UpdateCatalogModelRequestHealthCheck2
  | UpdateCatalogModelRequestHealthCheck3;

export type UpdateCatalogModelRequest = {
  provider?: string | undefined;
  modelId?: string | undefined;
  displayName?: string | null | undefined;
  baseUrl?: string | null | undefined;
  apiFormat?: AutoEndpoint | undefined;
  apiProviderType?: UpdateCatalogModelRequestApiProviderType | undefined;
  created?: number | undefined;
  auth?:
    | UpdateCatalogModelRequestAuth1
    | UpdateCatalogModelRequestAuth2
    | UpdateCatalogModelRequestAuth3
    | UpdateCatalogModelRequestAuth4
    | undefined;
  capabilities?: UpdateCatalogModelRequestCapabilities | undefined;
  contextWindow?: number | null | undefined;
  rpm?: number | null | undefined;
  rateLimits?: Array<UpdateCatalogModelRequestRateLimits> | null | undefined;
  concurrency?: UpdateCatalogModelRequestConcurrency | null | undefined;
  requestTimeoutMs?: number | null | undefined;
  maxRetries?: number | null | undefined;
  defaultParams?: UpdateCatalogModelRequestDefaultParams | null | undefined;
  rerouteRules?:
    | Array<UpdateCatalogModelRequestRerouteRules>
    | null
    | undefined;
  hidden?: boolean | null | undefined;
  embeddingLimits?: UpdateCatalogModelRequestEmbeddingLimits | null | undefined;
  healthCheck?:
    | UpdateCatalogModelRequestHealthCheck1
    | UpdateCatalogModelRequestHealthCheck2
    | UpdateCatalogModelRequestHealthCheck3
    | null
    | undefined;
  id: string;
};

/** @internal */
export const UpdateCatalogModelRequestApiProviderType$inboundSchema:
  z.ZodNativeEnum<typeof UpdateCatalogModelRequestApiProviderType> = z
    .nativeEnum(UpdateCatalogModelRequestApiProviderType);
/** @internal */
export const UpdateCatalogModelRequestApiProviderType$outboundSchema:
  z.ZodNativeEnum<typeof UpdateCatalogModelRequestApiProviderType> =
    UpdateCatalogModelRequestApiProviderType$inboundSchema;

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth4$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("composite"),
  strategies: z.any().optional(),
});
/** @internal */
export type UpdateCatalogModelRequestStrategiesAuth4$Outbound = {
  type: "composite";
  strategies?: any | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth4$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth4$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategiesAuth4
> = z.object({
  type: z.literal("composite"),
  strategies: z.any().optional(),
});

export function updateCatalogModelRequestStrategiesAuth4ToJSON(
  updateCatalogModelRequestStrategiesAuth4:
    UpdateCatalogModelRequestStrategiesAuth4,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategiesAuth4$outboundSchema.parse(
      updateCatalogModelRequestStrategiesAuth4,
    ),
  );
}
export function updateCatalogModelRequestStrategiesAuth4FromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestStrategiesAuth4,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategiesAuth4$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestStrategiesAuth4' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth3$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("none"),
});
/** @internal */
export type UpdateCatalogModelRequestStrategiesAuth3$Outbound = {
  type: "none";
};

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth3$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth3$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategiesAuth3
> = z.object({
  type: z.literal("none"),
});

export function updateCatalogModelRequestStrategiesAuth3ToJSON(
  updateCatalogModelRequestStrategiesAuth3:
    UpdateCatalogModelRequestStrategiesAuth3,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategiesAuth3$outboundSchema.parse(
      updateCatalogModelRequestStrategiesAuth3,
    ),
  );
}
export function updateCatalogModelRequestStrategiesAuth3FromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestStrategiesAuth3,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategiesAuth3$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestStrategiesAuth3' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth2$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("custom-headers"),
  headers: z.record(z.string()),
  envVars: z.record(z.string()).optional(),
});
/** @internal */
export type UpdateCatalogModelRequestStrategiesAuth2$Outbound = {
  type: "custom-headers";
  headers: { [k: string]: string };
  envVars?: { [k: string]: string } | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth2$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth2$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategiesAuth2
> = z.object({
  type: z.literal("custom-headers"),
  headers: z.record(z.string()),
  envVars: z.record(z.string()).optional(),
});

export function updateCatalogModelRequestStrategiesAuth2ToJSON(
  updateCatalogModelRequestStrategiesAuth2:
    UpdateCatalogModelRequestStrategiesAuth2,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategiesAuth2$outboundSchema.parse(
      updateCatalogModelRequestStrategiesAuth2,
    ),
  );
}
export function updateCatalogModelRequestStrategiesAuth2FromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestStrategiesAuth2,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategiesAuth2$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestStrategiesAuth2' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth1$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth1,
  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 UpdateCatalogModelRequestStrategiesAuth1$Outbound = {
  type: "api-key";
  value?: string | undefined;
  envVar?: string | undefined;
  headerName?: string | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestStrategiesAuth1$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategiesAuth1$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategiesAuth1
> = z.object({
  type: z.literal("api-key"),
  value: z.string().optional(),
  envVar: z.string().optional(),
  headerName: z.string().optional(),
});

export function updateCatalogModelRequestStrategiesAuth1ToJSON(
  updateCatalogModelRequestStrategiesAuth1:
    UpdateCatalogModelRequestStrategiesAuth1,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategiesAuth1$outboundSchema.parse(
      updateCatalogModelRequestStrategiesAuth1,
    ),
  );
}
export function updateCatalogModelRequestStrategiesAuth1FromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestStrategiesAuth1,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategiesAuth1$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestStrategiesAuth1' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategiesStrategies$inboundSchema:
  z.ZodType<
    UpdateCatalogModelRequestStrategiesStrategies,
    z.ZodTypeDef,
    unknown
  > = z.union([
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth1$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth2$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth3$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth4$inboundSchema),
  ]);
/** @internal */
export type UpdateCatalogModelRequestStrategiesStrategies$Outbound =
  | UpdateCatalogModelRequestStrategiesAuth1$Outbound
  | UpdateCatalogModelRequestStrategiesAuth2$Outbound
  | UpdateCatalogModelRequestStrategiesAuth3$Outbound
  | UpdateCatalogModelRequestStrategiesAuth4$Outbound;

/** @internal */
export const UpdateCatalogModelRequestStrategiesStrategies$outboundSchema:
  z.ZodType<
    UpdateCatalogModelRequestStrategiesStrategies$Outbound,
    z.ZodTypeDef,
    UpdateCatalogModelRequestStrategiesStrategies
  > = z.union([
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth1$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth2$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth3$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestStrategiesAuth4$outboundSchema),
  ]);

export function updateCatalogModelRequestStrategiesStrategiesToJSON(
  updateCatalogModelRequestStrategiesStrategies:
    UpdateCatalogModelRequestStrategiesStrategies,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategiesStrategies$outboundSchema.parse(
      updateCatalogModelRequestStrategiesStrategies,
    ),
  );
}
export function updateCatalogModelRequestStrategiesStrategiesFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestStrategiesStrategies,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategiesStrategies$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestStrategiesStrategies' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategies4$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("composite"),
  strategies: z.array(
    z.union([
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth1$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth2$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth3$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth4$inboundSchema),
    ]),
  ),
});
/** @internal */
export type UpdateCatalogModelRequestStrategies4$Outbound = {
  type: "composite";
  strategies: Array<
    | UpdateCatalogModelRequestStrategiesAuth1$Outbound
    | UpdateCatalogModelRequestStrategiesAuth2$Outbound
    | UpdateCatalogModelRequestStrategiesAuth3$Outbound
    | UpdateCatalogModelRequestStrategiesAuth4$Outbound
  >;
};

/** @internal */
export const UpdateCatalogModelRequestStrategies4$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies4$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategies4
> = z.object({
  type: z.literal("composite"),
  strategies: z.array(
    z.union([
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth1$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth2$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth3$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategiesAuth4$outboundSchema),
    ]),
  ),
});

export function updateCatalogModelRequestStrategies4ToJSON(
  updateCatalogModelRequestStrategies4: UpdateCatalogModelRequestStrategies4,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategies4$outboundSchema.parse(
      updateCatalogModelRequestStrategies4,
    ),
  );
}
export function updateCatalogModelRequestStrategies4FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestStrategies4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategies4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestStrategies4' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategies3$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("none"),
});
/** @internal */
export type UpdateCatalogModelRequestStrategies3$Outbound = {
  type: "none";
};

/** @internal */
export const UpdateCatalogModelRequestStrategies3$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies3$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategies3
> = z.object({
  type: z.literal("none"),
});

export function updateCatalogModelRequestStrategies3ToJSON(
  updateCatalogModelRequestStrategies3: UpdateCatalogModelRequestStrategies3,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategies3$outboundSchema.parse(
      updateCatalogModelRequestStrategies3,
    ),
  );
}
export function updateCatalogModelRequestStrategies3FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestStrategies3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategies3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestStrategies3' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategies2$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("custom-headers"),
  headers: z.record(z.string()),
  envVars: z.record(z.string()).optional(),
});
/** @internal */
export type UpdateCatalogModelRequestStrategies2$Outbound = {
  type: "custom-headers";
  headers: { [k: string]: string };
  envVars?: { [k: string]: string } | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestStrategies2$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies2$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategies2
> = z.object({
  type: z.literal("custom-headers"),
  headers: z.record(z.string()),
  envVars: z.record(z.string()).optional(),
});

export function updateCatalogModelRequestStrategies2ToJSON(
  updateCatalogModelRequestStrategies2: UpdateCatalogModelRequestStrategies2,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategies2$outboundSchema.parse(
      updateCatalogModelRequestStrategies2,
    ),
  );
}
export function updateCatalogModelRequestStrategies2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestStrategies2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategies2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestStrategies2' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestStrategies1$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies1,
  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 UpdateCatalogModelRequestStrategies1$Outbound = {
  type: "api-key";
  value?: string | undefined;
  envVar?: string | undefined;
  headerName?: string | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestStrategies1$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestStrategies1$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestStrategies1
> = z.object({
  type: z.literal("api-key"),
  value: z.string().optional(),
  envVar: z.string().optional(),
  headerName: z.string().optional(),
});

export function updateCatalogModelRequestStrategies1ToJSON(
  updateCatalogModelRequestStrategies1: UpdateCatalogModelRequestStrategies1,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestStrategies1$outboundSchema.parse(
      updateCatalogModelRequestStrategies1,
    ),
  );
}
export function updateCatalogModelRequestStrategies1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestStrategies1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestStrategies1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestStrategies1' from JSON`,
  );
}

/** @internal */
export const AuthStrategies$inboundSchema: z.ZodType<
  AuthStrategies,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestStrategies1$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestStrategies2$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestStrategies3$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestStrategies4$inboundSchema),
]);
/** @internal */
export type AuthStrategies$Outbound =
  | UpdateCatalogModelRequestStrategies1$Outbound
  | UpdateCatalogModelRequestStrategies2$Outbound
  | UpdateCatalogModelRequestStrategies3$Outbound
  | UpdateCatalogModelRequestStrategies4$Outbound;

/** @internal */
export const AuthStrategies$outboundSchema: z.ZodType<
  AuthStrategies$Outbound,
  z.ZodTypeDef,
  AuthStrategies
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestStrategies1$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestStrategies2$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestStrategies3$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestStrategies4$outboundSchema),
]);

export function authStrategiesToJSON(authStrategies: AuthStrategies): string {
  return JSON.stringify(AuthStrategies$outboundSchema.parse(authStrategies));
}
export function authStrategiesFromJSON(
  jsonString: string,
): SafeParseResult<AuthStrategies, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AuthStrategies$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AuthStrategies' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestAuth4$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("composite"),
  strategies: z.array(
    z.union([
      z.lazy(() => UpdateCatalogModelRequestStrategies1$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategies2$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategies3$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategies4$inboundSchema),
    ]),
  ),
});
/** @internal */
export type UpdateCatalogModelRequestAuth4$Outbound = {
  type: "composite";
  strategies: Array<
    | UpdateCatalogModelRequestStrategies1$Outbound
    | UpdateCatalogModelRequestStrategies2$Outbound
    | UpdateCatalogModelRequestStrategies3$Outbound
    | UpdateCatalogModelRequestStrategies4$Outbound
  >;
};

/** @internal */
export const UpdateCatalogModelRequestAuth4$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth4$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestAuth4
> = z.object({
  type: z.literal("composite"),
  strategies: z.array(
    z.union([
      z.lazy(() => UpdateCatalogModelRequestStrategies1$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategies2$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategies3$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestStrategies4$outboundSchema),
    ]),
  ),
});

export function updateCatalogModelRequestAuth4ToJSON(
  updateCatalogModelRequestAuth4: UpdateCatalogModelRequestAuth4,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestAuth4$outboundSchema.parse(
      updateCatalogModelRequestAuth4,
    ),
  );
}
export function updateCatalogModelRequestAuth4FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestAuth4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestAuth4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestAuth4' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestAuth3$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("none"),
});
/** @internal */
export type UpdateCatalogModelRequestAuth3$Outbound = {
  type: "none";
};

/** @internal */
export const UpdateCatalogModelRequestAuth3$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth3$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestAuth3
> = z.object({
  type: z.literal("none"),
});

export function updateCatalogModelRequestAuth3ToJSON(
  updateCatalogModelRequestAuth3: UpdateCatalogModelRequestAuth3,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestAuth3$outboundSchema.parse(
      updateCatalogModelRequestAuth3,
    ),
  );
}
export function updateCatalogModelRequestAuth3FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestAuth3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestAuth3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestAuth3' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestAuth2$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("custom-headers"),
  headers: z.record(z.string()),
  envVars: z.record(z.string()).optional(),
});
/** @internal */
export type UpdateCatalogModelRequestAuth2$Outbound = {
  type: "custom-headers";
  headers: { [k: string]: string };
  envVars?: { [k: string]: string } | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestAuth2$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth2$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestAuth2
> = z.object({
  type: z.literal("custom-headers"),
  headers: z.record(z.string()),
  envVars: z.record(z.string()).optional(),
});

export function updateCatalogModelRequestAuth2ToJSON(
  updateCatalogModelRequestAuth2: UpdateCatalogModelRequestAuth2,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestAuth2$outboundSchema.parse(
      updateCatalogModelRequestAuth2,
    ),
  );
}
export function updateCatalogModelRequestAuth2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestAuth2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestAuth2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestAuth2' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestAuth1$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth1,
  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 UpdateCatalogModelRequestAuth1$Outbound = {
  type: "api-key";
  value?: string | undefined;
  envVar?: string | undefined;
  headerName?: string | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestAuth1$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth1$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestAuth1
> = z.object({
  type: z.literal("api-key"),
  value: z.string().optional(),
  envVar: z.string().optional(),
  headerName: z.string().optional(),
});

export function updateCatalogModelRequestAuth1ToJSON(
  updateCatalogModelRequestAuth1: UpdateCatalogModelRequestAuth1,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestAuth1$outboundSchema.parse(
      updateCatalogModelRequestAuth1,
    ),
  );
}
export function updateCatalogModelRequestAuth1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestAuth1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestAuth1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestAuth1' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestAuth$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestAuth1$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestAuth2$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestAuth3$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestAuth4$inboundSchema),
]);
/** @internal */
export type UpdateCatalogModelRequestAuth$Outbound =
  | UpdateCatalogModelRequestAuth1$Outbound
  | UpdateCatalogModelRequestAuth2$Outbound
  | UpdateCatalogModelRequestAuth3$Outbound
  | UpdateCatalogModelRequestAuth4$Outbound;

/** @internal */
export const UpdateCatalogModelRequestAuth$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestAuth$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestAuth
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestAuth1$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestAuth2$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestAuth3$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestAuth4$outboundSchema),
]);

export function updateCatalogModelRequestAuthToJSON(
  updateCatalogModelRequestAuth: UpdateCatalogModelRequestAuth,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestAuth$outboundSchema.parse(
      updateCatalogModelRequestAuth,
    ),
  );
}
export function updateCatalogModelRequestAuthFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestAuth, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestAuth$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestAuth' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestInput$inboundSchema: z.ZodNativeEnum<
  typeof UpdateCatalogModelRequestInput
> = z.nativeEnum(UpdateCatalogModelRequestInput);
/** @internal */
export const UpdateCatalogModelRequestInput$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCatalogModelRequestInput
> = UpdateCatalogModelRequestInput$inboundSchema;

/** @internal */
export const UpdateCatalogModelRequestOutput$inboundSchema: z.ZodNativeEnum<
  typeof UpdateCatalogModelRequestOutput
> = z.nativeEnum(UpdateCatalogModelRequestOutput);
/** @internal */
export const UpdateCatalogModelRequestOutput$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCatalogModelRequestOutput
> = UpdateCatalogModelRequestOutput$inboundSchema;

/** @internal */
export const UpdateCatalogModelRequestModalities$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestModalities,
  z.ZodTypeDef,
  unknown
> = z.object({
  input: z.array(UpdateCatalogModelRequestInput$inboundSchema),
  output: z.array(UpdateCatalogModelRequestOutput$inboundSchema),
});
/** @internal */
export type UpdateCatalogModelRequestModalities$Outbound = {
  input: Array<string>;
  output: Array<string>;
};

/** @internal */
export const UpdateCatalogModelRequestModalities$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestModalities$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestModalities
> = z.object({
  input: z.array(UpdateCatalogModelRequestInput$outboundSchema),
  output: z.array(UpdateCatalogModelRequestOutput$outboundSchema),
});

export function updateCatalogModelRequestModalitiesToJSON(
  updateCatalogModelRequestModalities: UpdateCatalogModelRequestModalities,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestModalities$outboundSchema.parse(
      updateCatalogModelRequestModalities,
    ),
  );
}
export function updateCatalogModelRequestModalitiesFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestModalities, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestModalities$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestModalities' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestMaxImageResolution$inboundSchema:
  z.ZodType<
    UpdateCatalogModelRequestMaxImageResolution,
    z.ZodTypeDef,
    unknown
  > = z.object({
    maxWidth: z.number().int(),
    maxHeight: z.number().int(),
  });
/** @internal */
export type UpdateCatalogModelRequestMaxImageResolution$Outbound = {
  maxWidth: number;
  maxHeight: number;
};

/** @internal */
export const UpdateCatalogModelRequestMaxImageResolution$outboundSchema:
  z.ZodType<
    UpdateCatalogModelRequestMaxImageResolution$Outbound,
    z.ZodTypeDef,
    UpdateCatalogModelRequestMaxImageResolution
  > = z.object({
    maxWidth: z.number().int(),
    maxHeight: z.number().int(),
  });

export function updateCatalogModelRequestMaxImageResolutionToJSON(
  updateCatalogModelRequestMaxImageResolution:
    UpdateCatalogModelRequestMaxImageResolution,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestMaxImageResolution$outboundSchema.parse(
      updateCatalogModelRequestMaxImageResolution,
    ),
  );
}
export function updateCatalogModelRequestMaxImageResolutionFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestMaxImageResolution,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestMaxImageResolution$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestMaxImageResolution' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestMinImageResolution$inboundSchema:
  z.ZodType<
    UpdateCatalogModelRequestMinImageResolution,
    z.ZodTypeDef,
    unknown
  > = z.object({
    maxWidth: z.number().int(),
    maxHeight: z.number().int(),
  });
/** @internal */
export type UpdateCatalogModelRequestMinImageResolution$Outbound = {
  maxWidth: number;
  maxHeight: number;
};

/** @internal */
export const UpdateCatalogModelRequestMinImageResolution$outboundSchema:
  z.ZodType<
    UpdateCatalogModelRequestMinImageResolution$Outbound,
    z.ZodTypeDef,
    UpdateCatalogModelRequestMinImageResolution
  > = z.object({
    maxWidth: z.number().int(),
    maxHeight: z.number().int(),
  });

export function updateCatalogModelRequestMinImageResolutionToJSON(
  updateCatalogModelRequestMinImageResolution:
    UpdateCatalogModelRequestMinImageResolution,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestMinImageResolution$outboundSchema.parse(
      updateCatalogModelRequestMinImageResolution,
    ),
  );
}
export function updateCatalogModelRequestMinImageResolutionFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestMinImageResolution,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestMinImageResolution$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestMinImageResolution' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestCapabilities$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestCapabilities,
  z.ZodTypeDef,
  unknown
> = z.object({
  modalities: z.lazy(() => UpdateCatalogModelRequestModalities$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(() =>
    UpdateCatalogModelRequestMaxImageResolution$inboundSchema
  ).optional(),
  minImageResolution: z.lazy(() =>
    UpdateCatalogModelRequestMinImageResolution$inboundSchema
  ).optional(),
});
/** @internal */
export type UpdateCatalogModelRequestCapabilities$Outbound = {
  modalities: UpdateCatalogModelRequestModalities$Outbound;
  reasoning: boolean;
  supportedBase64Formats?: Array<string> | undefined;
  supportsCompletionVideoUrlMessage?: boolean | undefined;
  supportsTemperature?: boolean | undefined;
  supportsTopP?: boolean | undefined;
  maxImageResolution?:
    | UpdateCatalogModelRequestMaxImageResolution$Outbound
    | undefined;
  minImageResolution?:
    | UpdateCatalogModelRequestMinImageResolution$Outbound
    | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestCapabilities$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestCapabilities$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestCapabilities
> = z.object({
  modalities: z.lazy(() => UpdateCatalogModelRequestModalities$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(() =>
    UpdateCatalogModelRequestMaxImageResolution$outboundSchema
  ).optional(),
  minImageResolution: z.lazy(() =>
    UpdateCatalogModelRequestMinImageResolution$outboundSchema
  ).optional(),
});

export function updateCatalogModelRequestCapabilitiesToJSON(
  updateCatalogModelRequestCapabilities: UpdateCatalogModelRequestCapabilities,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestCapabilities$outboundSchema.parse(
      updateCatalogModelRequestCapabilities,
    ),
  );
}
export function updateCatalogModelRequestCapabilitiesFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestCapabilities, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestCapabilities$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestCapabilities' from JSON`,
  );
}

/** @internal */
export const RateLimitsScope$inboundSchema: z.ZodNativeEnum<
  typeof RateLimitsScope
> = z.nativeEnum(RateLimitsScope);
/** @internal */
export const RateLimitsScope$outboundSchema: z.ZodNativeEnum<
  typeof RateLimitsScope
> = RateLimitsScope$inboundSchema;

/** @internal */
export const RateLimitsQueue$inboundSchema: z.ZodType<
  RateLimitsQueue,
  z.ZodTypeDef,
  unknown
> = z.object({
  maxDepth: z.number().int(),
  maxWaitMs: z.number().int(),
});
/** @internal */
export type RateLimitsQueue$Outbound = {
  maxDepth: number;
  maxWaitMs: number;
};

/** @internal */
export const RateLimitsQueue$outboundSchema: z.ZodType<
  RateLimitsQueue$Outbound,
  z.ZodTypeDef,
  RateLimitsQueue
> = z.object({
  maxDepth: z.number().int(),
  maxWaitMs: z.number().int(),
});

export function rateLimitsQueueToJSON(
  rateLimitsQueue: RateLimitsQueue,
): string {
  return JSON.stringify(RateLimitsQueue$outboundSchema.parse(rateLimitsQueue));
}
export function rateLimitsQueueFromJSON(
  jsonString: string,
): SafeParseResult<RateLimitsQueue, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => RateLimitsQueue$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'RateLimitsQueue' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestRateLimits$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestRateLimits,
  z.ZodTypeDef,
  unknown
> = z.object({
  scope: RateLimitsScope$inboundSchema,
  rpm: z.number().int(),
  duration: z.number().int().optional(),
  queue: z.lazy(() => RateLimitsQueue$inboundSchema).optional(),
});
/** @internal */
export type UpdateCatalogModelRequestRateLimits$Outbound = {
  scope: string;
  rpm: number;
  duration?: number | undefined;
  queue?: RateLimitsQueue$Outbound | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestRateLimits$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestRateLimits$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestRateLimits
> = z.object({
  scope: RateLimitsScope$outboundSchema,
  rpm: z.number().int(),
  duration: z.number().int().optional(),
  queue: z.lazy(() => RateLimitsQueue$outboundSchema).optional(),
});

export function updateCatalogModelRequestRateLimitsToJSON(
  updateCatalogModelRequestRateLimits: UpdateCatalogModelRequestRateLimits,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestRateLimits$outboundSchema.parse(
      updateCatalogModelRequestRateLimits,
    ),
  );
}
export function updateCatalogModelRequestRateLimitsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestRateLimits, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestRateLimits$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestRateLimits' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestConcurrency$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestConcurrency,
  z.ZodTypeDef,
  unknown
> = z.object({
  max: z.number().int(),
  maxWaitMs: z.number().int().optional(),
});
/** @internal */
export type UpdateCatalogModelRequestConcurrency$Outbound = {
  max: number;
  maxWaitMs?: number | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestConcurrency$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestConcurrency$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestConcurrency
> = z.object({
  max: z.number().int(),
  maxWaitMs: z.number().int().optional(),
});

export function updateCatalogModelRequestConcurrencyToJSON(
  updateCatalogModelRequestConcurrency: UpdateCatalogModelRequestConcurrency,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestConcurrency$outboundSchema.parse(
      updateCatalogModelRequestConcurrency,
    ),
  );
}
export function updateCatalogModelRequestConcurrencyFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestConcurrency, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestConcurrency$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestConcurrency' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestDefaultParams$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestDefaultParams,
  z.ZodTypeDef,
  unknown
> = z.object({
  temperature: z.number().optional(),
  topP: z.number().optional(),
  presencePenalty: z.number().optional(),
  frequencyPenalty: z.number().optional(),
});
/** @internal */
export type UpdateCatalogModelRequestDefaultParams$Outbound = {
  temperature?: number | undefined;
  topP?: number | undefined;
  presencePenalty?: number | undefined;
  frequencyPenalty?: number | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestDefaultParams$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestDefaultParams$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestDefaultParams
> = z.object({
  temperature: z.number().optional(),
  topP: z.number().optional(),
  presencePenalty: z.number().optional(),
  frequencyPenalty: z.number().optional(),
});

export function updateCatalogModelRequestDefaultParamsToJSON(
  updateCatalogModelRequestDefaultParams:
    UpdateCatalogModelRequestDefaultParams,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestDefaultParams$outboundSchema.parse(
      updateCatalogModelRequestDefaultParams,
    ),
  );
}
export function updateCatalogModelRequestDefaultParamsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestDefaultParams, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestDefaultParams$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestDefaultParams' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestTrigger4$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("error-fallback"),
});
/** @internal */
export type UpdateCatalogModelRequestTrigger4$Outbound = {
  type: "error-fallback";
};

/** @internal */
export const UpdateCatalogModelRequestTrigger4$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger4$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestTrigger4
> = z.object({
  type: z.literal("error-fallback"),
});

export function updateCatalogModelRequestTrigger4ToJSON(
  updateCatalogModelRequestTrigger4: UpdateCatalogModelRequestTrigger4,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestTrigger4$outboundSchema.parse(
      updateCatalogModelRequestTrigger4,
    ),
  );
}
export function updateCatalogModelRequestTrigger4FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestTrigger4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestTrigger4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestTrigger4' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestTrigger3$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("context-exceeded"),
});
/** @internal */
export type UpdateCatalogModelRequestTrigger3$Outbound = {
  type: "context-exceeded";
};

/** @internal */
export const UpdateCatalogModelRequestTrigger3$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger3$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestTrigger3
> = z.object({
  type: z.literal("context-exceeded"),
});

export function updateCatalogModelRequestTrigger3ToJSON(
  updateCatalogModelRequestTrigger3: UpdateCatalogModelRequestTrigger3,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestTrigger3$outboundSchema.parse(
      updateCatalogModelRequestTrigger3,
    ),
  );
}
export function updateCatalogModelRequestTrigger3FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestTrigger3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestTrigger3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestTrigger3' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestTrigger2$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("base64-input"),
});
/** @internal */
export type UpdateCatalogModelRequestTrigger2$Outbound = {
  type: "base64-input";
};

/** @internal */
export const UpdateCatalogModelRequestTrigger2$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger2$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestTrigger2
> = z.object({
  type: z.literal("base64-input"),
});

export function updateCatalogModelRequestTrigger2ToJSON(
  updateCatalogModelRequestTrigger2: UpdateCatalogModelRequestTrigger2,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestTrigger2$outboundSchema.parse(
      updateCatalogModelRequestTrigger2,
    ),
  );
}
export function updateCatalogModelRequestTrigger2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestTrigger2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestTrigger2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestTrigger2' from JSON`,
  );
}

/** @internal */
export const TriggerModality$inboundSchema: z.ZodNativeEnum<
  typeof TriggerModality
> = z.nativeEnum(TriggerModality);
/** @internal */
export const TriggerModality$outboundSchema: z.ZodNativeEnum<
  typeof TriggerModality
> = TriggerModality$inboundSchema;

/** @internal */
export const UpdateCatalogModelRequestTrigger1$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("input-modality"),
  modality: TriggerModality$inboundSchema,
});
/** @internal */
export type UpdateCatalogModelRequestTrigger1$Outbound = {
  type: "input-modality";
  modality: string;
};

/** @internal */
export const UpdateCatalogModelRequestTrigger1$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestTrigger1$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestTrigger1
> = z.object({
  type: z.literal("input-modality"),
  modality: TriggerModality$outboundSchema,
});

export function updateCatalogModelRequestTrigger1ToJSON(
  updateCatalogModelRequestTrigger1: UpdateCatalogModelRequestTrigger1,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestTrigger1$outboundSchema.parse(
      updateCatalogModelRequestTrigger1,
    ),
  );
}
export function updateCatalogModelRequestTrigger1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestTrigger1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequestTrigger1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestTrigger1' from JSON`,
  );
}

/** @internal */
export const RerouteRulesTrigger$inboundSchema: z.ZodType<
  RerouteRulesTrigger,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestTrigger1$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestTrigger2$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestTrigger3$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestTrigger4$inboundSchema),
]);
/** @internal */
export type RerouteRulesTrigger$Outbound =
  | UpdateCatalogModelRequestTrigger1$Outbound
  | UpdateCatalogModelRequestTrigger2$Outbound
  | UpdateCatalogModelRequestTrigger3$Outbound
  | UpdateCatalogModelRequestTrigger4$Outbound;

/** @internal */
export const RerouteRulesTrigger$outboundSchema: z.ZodType<
  RerouteRulesTrigger$Outbound,
  z.ZodTypeDef,
  RerouteRulesTrigger
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestTrigger1$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestTrigger2$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestTrigger3$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestTrigger4$outboundSchema),
]);

export function rerouteRulesTriggerToJSON(
  rerouteRulesTrigger: RerouteRulesTrigger,
): string {
  return JSON.stringify(
    RerouteRulesTrigger$outboundSchema.parse(rerouteRulesTrigger),
  );
}
export function rerouteRulesTriggerFromJSON(
  jsonString: string,
): SafeParseResult<RerouteRulesTrigger, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => RerouteRulesTrigger$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'RerouteRulesTrigger' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestRerouteRules$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestRerouteRules,
  z.ZodTypeDef,
  unknown
> = z.object({
  trigger: z.union([
    z.lazy(() => UpdateCatalogModelRequestTrigger1$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestTrigger2$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestTrigger3$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestTrigger4$inboundSchema),
  ]),
  targetModelId: z.string(),
  preserveParams: z.boolean().optional(),
  log: z.boolean().optional(),
});
/** @internal */
export type UpdateCatalogModelRequestRerouteRules$Outbound = {
  trigger:
    | UpdateCatalogModelRequestTrigger1$Outbound
    | UpdateCatalogModelRequestTrigger2$Outbound
    | UpdateCatalogModelRequestTrigger3$Outbound
    | UpdateCatalogModelRequestTrigger4$Outbound;
  targetModelId: string;
  preserveParams?: boolean | undefined;
  log?: boolean | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestRerouteRules$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestRerouteRules$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestRerouteRules
> = z.object({
  trigger: z.union([
    z.lazy(() => UpdateCatalogModelRequestTrigger1$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestTrigger2$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestTrigger3$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestTrigger4$outboundSchema),
  ]),
  targetModelId: z.string(),
  preserveParams: z.boolean().optional(),
  log: z.boolean().optional(),
});

export function updateCatalogModelRequestRerouteRulesToJSON(
  updateCatalogModelRequestRerouteRules: UpdateCatalogModelRequestRerouteRules,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestRerouteRules$outboundSchema.parse(
      updateCatalogModelRequestRerouteRules,
    ),
  );
}
export function updateCatalogModelRequestRerouteRulesFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestRerouteRules, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestRerouteRules$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestRerouteRules' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestDimensions2$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestDimensions2,
  z.ZodTypeDef,
  unknown
> = z.object({
  min: z.number().int(),
  max: z.number().int(),
  default: z.number().int(),
});
/** @internal */
export type UpdateCatalogModelRequestDimensions2$Outbound = {
  min: number;
  max: number;
  default: number;
};

/** @internal */
export const UpdateCatalogModelRequestDimensions2$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestDimensions2$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestDimensions2
> = z.object({
  min: z.number().int(),
  max: z.number().int(),
  default: z.number().int(),
});

export function updateCatalogModelRequestDimensions2ToJSON(
  updateCatalogModelRequestDimensions2: UpdateCatalogModelRequestDimensions2,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestDimensions2$outboundSchema.parse(
      updateCatalogModelRequestDimensions2,
    ),
  );
}
export function updateCatalogModelRequestDimensions2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestDimensions2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestDimensions2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestDimensions2' from JSON`,
  );
}

/** @internal */
export const EmbeddingLimitsDimensions$inboundSchema: z.ZodType<
  EmbeddingLimitsDimensions,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestDimensions2$inboundSchema),
  z.number().int(),
]);
/** @internal */
export type EmbeddingLimitsDimensions$Outbound =
  | UpdateCatalogModelRequestDimensions2$Outbound
  | number;

/** @internal */
export const EmbeddingLimitsDimensions$outboundSchema: z.ZodType<
  EmbeddingLimitsDimensions$Outbound,
  z.ZodTypeDef,
  EmbeddingLimitsDimensions
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestDimensions2$outboundSchema),
  z.number().int(),
]);

export function embeddingLimitsDimensionsToJSON(
  embeddingLimitsDimensions: EmbeddingLimitsDimensions,
): string {
  return JSON.stringify(
    EmbeddingLimitsDimensions$outboundSchema.parse(embeddingLimitsDimensions),
  );
}
export function embeddingLimitsDimensionsFromJSON(
  jsonString: string,
): SafeParseResult<EmbeddingLimitsDimensions, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => EmbeddingLimitsDimensions$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'EmbeddingLimitsDimensions' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestEmbeddingLimits$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestEmbeddingLimits,
  z.ZodTypeDef,
  unknown
> = z.object({
  maxBatchSize: z.number().int().optional(),
  dimensions: z.union([
    z.lazy(() => UpdateCatalogModelRequestDimensions2$inboundSchema),
    z.number().int(),
  ]).optional(),
});
/** @internal */
export type UpdateCatalogModelRequestEmbeddingLimits$Outbound = {
  maxBatchSize?: number | undefined;
  dimensions?:
    | UpdateCatalogModelRequestDimensions2$Outbound
    | number
    | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestEmbeddingLimits$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestEmbeddingLimits$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestEmbeddingLimits
> = z.object({
  maxBatchSize: z.number().int().optional(),
  dimensions: z.union([
    z.lazy(() => UpdateCatalogModelRequestDimensions2$outboundSchema),
    z.number().int(),
  ]).optional(),
});

export function updateCatalogModelRequestEmbeddingLimitsToJSON(
  updateCatalogModelRequestEmbeddingLimits:
    UpdateCatalogModelRequestEmbeddingLimits,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestEmbeddingLimits$outboundSchema.parse(
      updateCatalogModelRequestEmbeddingLimits,
    ),
  );
}
export function updateCatalogModelRequestEmbeddingLimitsFromJSON(
  jsonString: string,
): SafeParseResult<
  UpdateCatalogModelRequestEmbeddingLimits,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestEmbeddingLimits$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'UpdateCatalogModelRequestEmbeddingLimits' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestHealthCheck3Method$inboundSchema:
  z.ZodNativeEnum<typeof UpdateCatalogModelRequestHealthCheck3Method> = z
    .nativeEnum(UpdateCatalogModelRequestHealthCheck3Method);
/** @internal */
export const UpdateCatalogModelRequestHealthCheck3Method$outboundSchema:
  z.ZodNativeEnum<typeof UpdateCatalogModelRequestHealthCheck3Method> =
    UpdateCatalogModelRequestHealthCheck3Method$inboundSchema;

/** @internal */
export const UpdateCatalogModelRequestHealthCheck3$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck3,
  z.ZodTypeDef,
  unknown
> = z.object({
  mode: z.literal("periodic"),
  intervalSeconds: z.number().int(),
  path: z.string(),
  method: UpdateCatalogModelRequestHealthCheck3Method$inboundSchema.optional(),
  timeoutMs: z.number().int().optional(),
  cacheTtlSeconds: z.number().int().optional(),
});
/** @internal */
export type UpdateCatalogModelRequestHealthCheck3$Outbound = {
  mode: "periodic";
  intervalSeconds: number;
  path: string;
  method?: string | undefined;
  timeoutMs?: number | undefined;
  cacheTtlSeconds?: number | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestHealthCheck3$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck3$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestHealthCheck3
> = z.object({
  mode: z.literal("periodic"),
  intervalSeconds: z.number().int(),
  path: z.string(),
  method: UpdateCatalogModelRequestHealthCheck3Method$outboundSchema.optional(),
  timeoutMs: z.number().int().optional(),
  cacheTtlSeconds: z.number().int().optional(),
});

export function updateCatalogModelRequestHealthCheck3ToJSON(
  updateCatalogModelRequestHealthCheck3: UpdateCatalogModelRequestHealthCheck3,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestHealthCheck3$outboundSchema.parse(
      updateCatalogModelRequestHealthCheck3,
    ),
  );
}
export function updateCatalogModelRequestHealthCheck3FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestHealthCheck3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestHealthCheck3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestHealthCheck3' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestHealthCheckMethod$inboundSchema:
  z.ZodNativeEnum<typeof UpdateCatalogModelRequestHealthCheckMethod> = z
    .nativeEnum(UpdateCatalogModelRequestHealthCheckMethod);
/** @internal */
export const UpdateCatalogModelRequestHealthCheckMethod$outboundSchema:
  z.ZodNativeEnum<typeof UpdateCatalogModelRequestHealthCheckMethod> =
    UpdateCatalogModelRequestHealthCheckMethod$inboundSchema;

/** @internal */
export const UpdateCatalogModelRequestHealthCheck2$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck2,
  z.ZodTypeDef,
  unknown
> = z.object({
  mode: z.literal("preflight"),
  path: z.string(),
  method: UpdateCatalogModelRequestHealthCheckMethod$inboundSchema.optional(),
  timeoutMs: z.number().int().optional(),
  cacheTtlSeconds: z.number().int().optional(),
});
/** @internal */
export type UpdateCatalogModelRequestHealthCheck2$Outbound = {
  mode: "preflight";
  path: string;
  method?: string | undefined;
  timeoutMs?: number | undefined;
  cacheTtlSeconds?: number | undefined;
};

/** @internal */
export const UpdateCatalogModelRequestHealthCheck2$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck2$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestHealthCheck2
> = z.object({
  mode: z.literal("preflight"),
  path: z.string(),
  method: UpdateCatalogModelRequestHealthCheckMethod$outboundSchema.optional(),
  timeoutMs: z.number().int().optional(),
  cacheTtlSeconds: z.number().int().optional(),
});

export function updateCatalogModelRequestHealthCheck2ToJSON(
  updateCatalogModelRequestHealthCheck2: UpdateCatalogModelRequestHealthCheck2,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestHealthCheck2$outboundSchema.parse(
      updateCatalogModelRequestHealthCheck2,
    ),
  );
}
export function updateCatalogModelRequestHealthCheck2FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestHealthCheck2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestHealthCheck2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestHealthCheck2' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestHealthCheck1$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck1,
  z.ZodTypeDef,
  unknown
> = z.object({
  mode: z.literal("off"),
});
/** @internal */
export type UpdateCatalogModelRequestHealthCheck1$Outbound = {
  mode: "off";
};

/** @internal */
export const UpdateCatalogModelRequestHealthCheck1$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck1$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestHealthCheck1
> = z.object({
  mode: z.literal("off"),
});

export function updateCatalogModelRequestHealthCheck1ToJSON(
  updateCatalogModelRequestHealthCheck1: UpdateCatalogModelRequestHealthCheck1,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestHealthCheck1$outboundSchema.parse(
      updateCatalogModelRequestHealthCheck1,
    ),
  );
}
export function updateCatalogModelRequestHealthCheck1FromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestHealthCheck1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestHealthCheck1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestHealthCheck1' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequestHealthCheck$inboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestHealthCheck1$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestHealthCheck2$inboundSchema),
  z.lazy(() => UpdateCatalogModelRequestHealthCheck3$inboundSchema),
]);
/** @internal */
export type UpdateCatalogModelRequestHealthCheck$Outbound =
  | UpdateCatalogModelRequestHealthCheck1$Outbound
  | UpdateCatalogModelRequestHealthCheck2$Outbound
  | UpdateCatalogModelRequestHealthCheck3$Outbound;

/** @internal */
export const UpdateCatalogModelRequestHealthCheck$outboundSchema: z.ZodType<
  UpdateCatalogModelRequestHealthCheck$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequestHealthCheck
> = z.union([
  z.lazy(() => UpdateCatalogModelRequestHealthCheck1$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestHealthCheck2$outboundSchema),
  z.lazy(() => UpdateCatalogModelRequestHealthCheck3$outboundSchema),
]);

export function updateCatalogModelRequestHealthCheckToJSON(
  updateCatalogModelRequestHealthCheck: UpdateCatalogModelRequestHealthCheck,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequestHealthCheck$outboundSchema.parse(
      updateCatalogModelRequestHealthCheck,
    ),
  );
}
export function updateCatalogModelRequestHealthCheckFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequestHealthCheck, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateCatalogModelRequestHealthCheck$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequestHealthCheck' from JSON`,
  );
}

/** @internal */
export const UpdateCatalogModelRequest$inboundSchema: z.ZodType<
  UpdateCatalogModelRequest,
  z.ZodTypeDef,
  unknown
> = z.object({
  provider: z.string().optional(),
  modelId: z.string().optional(),
  displayName: z.nullable(z.string()).optional(),
  baseUrl: z.nullable(z.string()).optional(),
  apiFormat: AutoEndpoint$inboundSchema.optional(),
  apiProviderType: UpdateCatalogModelRequestApiProviderType$inboundSchema
    .optional(),
  created: z.number().int().optional(),
  auth: z.union([
    z.lazy(() => UpdateCatalogModelRequestAuth1$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestAuth2$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestAuth3$inboundSchema),
    z.lazy(() => UpdateCatalogModelRequestAuth4$inboundSchema),
  ]).optional(),
  capabilities: z.lazy(() =>
    UpdateCatalogModelRequestCapabilities$inboundSchema
  ).optional(),
  contextWindow: z.nullable(z.number().int()).optional(),
  rpm: z.nullable(z.number().int()).optional(),
  rateLimits: z.nullable(
    z.array(z.lazy(() => UpdateCatalogModelRequestRateLimits$inboundSchema)),
  ).optional(),
  concurrency: z.nullable(
    z.lazy(() => UpdateCatalogModelRequestConcurrency$inboundSchema),
  ).optional(),
  requestTimeoutMs: z.nullable(z.number().int()).optional(),
  maxRetries: z.nullable(z.number().int()).optional(),
  defaultParams: z.nullable(
    z.lazy(() => UpdateCatalogModelRequestDefaultParams$inboundSchema),
  ).optional(),
  rerouteRules: z.nullable(
    z.array(z.lazy(() => UpdateCatalogModelRequestRerouteRules$inboundSchema)),
  ).optional(),
  hidden: z.nullable(z.boolean()).optional(),
  embeddingLimits: z.nullable(
    z.lazy(() => UpdateCatalogModelRequestEmbeddingLimits$inboundSchema),
  ).optional(),
  healthCheck: z.nullable(
    z.union([
      z.lazy(() => UpdateCatalogModelRequestHealthCheck1$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestHealthCheck2$inboundSchema),
      z.lazy(() => UpdateCatalogModelRequestHealthCheck3$inboundSchema),
    ]),
  ).optional(),
  id: z.string(),
});
/** @internal */
export type UpdateCatalogModelRequest$Outbound = {
  provider?: string | undefined;
  modelId?: string | undefined;
  displayName?: string | null | undefined;
  baseUrl?: string | null | undefined;
  apiFormat?: string | undefined;
  apiProviderType?: string | undefined;
  created?: number | undefined;
  auth?:
    | UpdateCatalogModelRequestAuth1$Outbound
    | UpdateCatalogModelRequestAuth2$Outbound
    | UpdateCatalogModelRequestAuth3$Outbound
    | UpdateCatalogModelRequestAuth4$Outbound
    | undefined;
  capabilities?: UpdateCatalogModelRequestCapabilities$Outbound | undefined;
  contextWindow?: number | null | undefined;
  rpm?: number | null | undefined;
  rateLimits?:
    | Array<UpdateCatalogModelRequestRateLimits$Outbound>
    | null
    | undefined;
  concurrency?:
    | UpdateCatalogModelRequestConcurrency$Outbound
    | null
    | undefined;
  requestTimeoutMs?: number | null | undefined;
  maxRetries?: number | null | undefined;
  defaultParams?:
    | UpdateCatalogModelRequestDefaultParams$Outbound
    | null
    | undefined;
  rerouteRules?:
    | Array<UpdateCatalogModelRequestRerouteRules$Outbound>
    | null
    | undefined;
  hidden?: boolean | null | undefined;
  embeddingLimits?:
    | UpdateCatalogModelRequestEmbeddingLimits$Outbound
    | null
    | undefined;
  healthCheck?:
    | UpdateCatalogModelRequestHealthCheck1$Outbound
    | UpdateCatalogModelRequestHealthCheck2$Outbound
    | UpdateCatalogModelRequestHealthCheck3$Outbound
    | null
    | undefined;
  id: string;
};

/** @internal */
export const UpdateCatalogModelRequest$outboundSchema: z.ZodType<
  UpdateCatalogModelRequest$Outbound,
  z.ZodTypeDef,
  UpdateCatalogModelRequest
> = z.object({
  provider: z.string().optional(),
  modelId: z.string().optional(),
  displayName: z.nullable(z.string()).optional(),
  baseUrl: z.nullable(z.string()).optional(),
  apiFormat: AutoEndpoint$outboundSchema.optional(),
  apiProviderType: UpdateCatalogModelRequestApiProviderType$outboundSchema
    .optional(),
  created: z.number().int().optional(),
  auth: z.union([
    z.lazy(() => UpdateCatalogModelRequestAuth1$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestAuth2$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestAuth3$outboundSchema),
    z.lazy(() => UpdateCatalogModelRequestAuth4$outboundSchema),
  ]).optional(),
  capabilities: z.lazy(() =>
    UpdateCatalogModelRequestCapabilities$outboundSchema
  ).optional(),
  contextWindow: z.nullable(z.number().int()).optional(),
  rpm: z.nullable(z.number().int()).optional(),
  rateLimits: z.nullable(
    z.array(z.lazy(() => UpdateCatalogModelRequestRateLimits$outboundSchema)),
  ).optional(),
  concurrency: z.nullable(
    z.lazy(() => UpdateCatalogModelRequestConcurrency$outboundSchema),
  ).optional(),
  requestTimeoutMs: z.nullable(z.number().int()).optional(),
  maxRetries: z.nullable(z.number().int()).optional(),
  defaultParams: z.nullable(
    z.lazy(() => UpdateCatalogModelRequestDefaultParams$outboundSchema),
  ).optional(),
  rerouteRules: z.nullable(
    z.array(z.lazy(() => UpdateCatalogModelRequestRerouteRules$outboundSchema)),
  ).optional(),
  hidden: z.nullable(z.boolean()).optional(),
  embeddingLimits: z.nullable(
    z.lazy(() => UpdateCatalogModelRequestEmbeddingLimits$outboundSchema),
  ).optional(),
  healthCheck: z.nullable(
    z.union([
      z.lazy(() => UpdateCatalogModelRequestHealthCheck1$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestHealthCheck2$outboundSchema),
      z.lazy(() => UpdateCatalogModelRequestHealthCheck3$outboundSchema),
    ]),
  ).optional(),
  id: z.string(),
});

export function updateCatalogModelRequestToJSON(
  updateCatalogModelRequest: UpdateCatalogModelRequest,
): string {
  return JSON.stringify(
    UpdateCatalogModelRequest$outboundSchema.parse(updateCatalogModelRequest),
  );
}
export function updateCatalogModelRequestFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCatalogModelRequest, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCatalogModelRequest$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCatalogModelRequest' from JSON`,
  );
}