@meetkai/mka1 0.49.14 → 0.49.16

package/dist/esm/models/components/addcatalogmodelrequest.d.ts

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