/**
 * Cloudflare AI-GATEWAY API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service ai-gateway
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
declare const GatewayAlreadyExists_base: Schema.Class<GatewayAlreadyExists, Schema.TaggedStruct<"GatewayAlreadyExists", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class GatewayAlreadyExists extends GatewayAlreadyExists_base {
}
declare const GatewayNotFound_base: Schema.Class<GatewayNotFound, Schema.TaggedStruct<"GatewayNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class GatewayNotFound extends GatewayNotFound_base {
}
declare const NoManualTopup_base: Schema.Class<NoManualTopup, Schema.TaggedStruct<"NoManualTopup", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class NoManualTopup extends NoManualTopup_base {
}
export interface GetAiGatewayRequest {
    id: string;
    accountId: string;
}
export declare const GetAiGatewayRequest: Schema.Schema<GetAiGatewayRequest>;
export interface GetAiGatewayResponse {
    /** gateway id */
    id: string;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG" | (string & {});
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK" | (string & {});
            check: ("REQUEST" | "RESPONSE" | (string & {}))[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | null;
    guardrails?: {
        prompt: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
        response: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
    } | null;
    isDefault?: boolean | null;
    logManagement?: number | null;
    logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
    logpush?: boolean | null;
    logpushPublicKey?: string | null;
    otel?: {
        authorization: string;
        headers: Record<string, unknown>;
        url: string;
        contentType?: "json" | "protobuf" | (string & {}) | null;
    }[] | null;
    rateLimitingTechnique?: "fixed" | "sliding" | null;
    /** Backoff strategy for retry delays */
    retryBackoff?: "constant" | "linear" | "exponential" | null;
    /** Delay between retry attempts in milliseconds (0-5000) */
    retryDelay?: number | null;
    /** Maximum number of retry attempts for failed requests (1-5) */
    retryMaxAttempts?: number | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | null;
    /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
    workersAiBillingMode?: "postpaid" | null;
    zdr?: boolean | null;
}
export declare const GetAiGatewayResponse: Schema.Schema<GetAiGatewayResponse>;
export type GetAiGatewayError = DefaultErrors | GatewayNotFound;
export declare const getAiGateway: API.OperationMethod<GetAiGatewayRequest, GetAiGatewayResponse, GetAiGatewayError, Credentials | HttpClient.HttpClient>;
export interface ListAiGatewaysRequest {
    /** Path param */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Search by id */
    search?: string;
}
export declare const ListAiGatewaysRequest: Schema.Schema<ListAiGatewaysRequest>;
export interface ListAiGatewaysResponse {
    result: {
        id: string;
        cacheInvalidateOnUpdate: boolean;
        cacheTtl: number | null;
        collectLogs: boolean;
        createdAt: string;
        modifiedAt: string;
        rateLimitingInterval: number | null;
        rateLimitingLimit: number | null;
        authentication?: boolean | null;
        dlp?: {
            action: "BLOCK" | "FLAG" | (string & {});
            enabled: boolean;
            profiles: string[];
        } | {
            enabled: boolean;
            policies: {
                id: string;
                action: "FLAG" | "BLOCK" | (string & {});
                check: ("REQUEST" | "RESPONSE" | (string & {}))[];
                enabled: boolean;
                profiles: string[];
            }[];
        } | null;
        guardrails?: {
            prompt: {
                p1?: "FLAG" | "BLOCK" | (string & {}) | null;
                s1?: "FLAG" | "BLOCK" | (string & {}) | null;
                s10?: "FLAG" | "BLOCK" | (string & {}) | null;
                s11?: "FLAG" | "BLOCK" | (string & {}) | null;
                s12?: "FLAG" | "BLOCK" | (string & {}) | null;
                s13?: "FLAG" | "BLOCK" | (string & {}) | null;
                s2?: "FLAG" | "BLOCK" | (string & {}) | null;
                s3?: "FLAG" | "BLOCK" | (string & {}) | null;
                s4?: "FLAG" | "BLOCK" | (string & {}) | null;
                s5?: "FLAG" | "BLOCK" | (string & {}) | null;
                s6?: "FLAG" | "BLOCK" | (string & {}) | null;
                s7?: "FLAG" | "BLOCK" | (string & {}) | null;
                s8?: "FLAG" | "BLOCK" | (string & {}) | null;
                s9?: "FLAG" | "BLOCK" | (string & {}) | null;
            };
            response: {
                p1?: "FLAG" | "BLOCK" | (string & {}) | null;
                s1?: "FLAG" | "BLOCK" | (string & {}) | null;
                s10?: "FLAG" | "BLOCK" | (string & {}) | null;
                s11?: "FLAG" | "BLOCK" | (string & {}) | null;
                s12?: "FLAG" | "BLOCK" | (string & {}) | null;
                s13?: "FLAG" | "BLOCK" | (string & {}) | null;
                s2?: "FLAG" | "BLOCK" | (string & {}) | null;
                s3?: "FLAG" | "BLOCK" | (string & {}) | null;
                s4?: "FLAG" | "BLOCK" | (string & {}) | null;
                s5?: "FLAG" | "BLOCK" | (string & {}) | null;
                s6?: "FLAG" | "BLOCK" | (string & {}) | null;
                s7?: "FLAG" | "BLOCK" | (string & {}) | null;
                s8?: "FLAG" | "BLOCK" | (string & {}) | null;
                s9?: "FLAG" | "BLOCK" | (string & {}) | null;
            };
        } | null;
        isDefault?: boolean | null;
        logManagement?: number | null;
        logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
        logpush?: boolean | null;
        logpushPublicKey?: string | null;
        otel?: {
            authorization: string;
            headers: Record<string, unknown>;
            url: string;
            contentType?: "json" | "protobuf" | (string & {}) | null;
        }[] | null;
        rateLimitingTechnique?: "fixed" | "sliding" | null;
        retryBackoff?: "constant" | "linear" | "exponential" | null;
        retryDelay?: number | null;
        retryMaxAttempts?: number | null;
        storeId?: string | null;
        stripe?: {
            authorization: string;
            usageEvents: {
                payload: string;
            }[];
        } | null;
        workersAiBillingMode?: "postpaid" | null;
        zdr?: boolean | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListAiGatewaysResponse: Schema.Schema<ListAiGatewaysResponse>;
export type ListAiGatewaysError = DefaultErrors;
export declare const listAiGateways: API.PaginatedOperationMethod<ListAiGatewaysRequest, ListAiGatewaysResponse, ListAiGatewaysError, Credentials | HttpClient.HttpClient>;
export interface CreateAiGatewayRequest {
    /** Path param */
    accountId: string;
    /** Body param: gateway id */
    id: string;
    /** Body param */
    cacheInvalidateOnUpdate: boolean;
    /** Body param */
    cacheTtl: number | null;
    /** Body param */
    collectLogs: boolean;
    /** Body param */
    rateLimitingInterval: number | null;
    /** Body param */
    rateLimitingLimit: number | null;
    /** Body param */
    authentication?: boolean;
    /** Body param */
    logManagement?: number | null;
    /** Body param */
    logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
    /** Body param */
    logpush?: boolean;
    /** Body param */
    logpushPublicKey?: string | null;
    /** Body param */
    rateLimitingTechnique?: "fixed" | "sliding" | null;
    /** Body param: Backoff strategy for retry delays */
    retryBackoff?: "constant" | "linear" | "exponential" | null;
    /** Body param: Delay between retry attempts in milliseconds (0-5000) */
    retryDelay?: number | null;
    /** Body param: Maximum number of retry attempts for failed requests (1-5) */
    retryMaxAttempts?: number | null;
    /** Body param: Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
    workersAiBillingMode?: "postpaid";
    /** Body param */
    zdr?: boolean;
}
export declare const CreateAiGatewayRequest: Schema.Schema<CreateAiGatewayRequest>;
export interface CreateAiGatewayResponse {
    /** gateway id */
    id: string;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG" | (string & {});
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK" | (string & {});
            check: ("REQUEST" | "RESPONSE" | (string & {}))[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | null;
    guardrails?: {
        prompt: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
        response: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
    } | null;
    isDefault?: boolean | null;
    logManagement?: number | null;
    logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
    logpush?: boolean | null;
    logpushPublicKey?: string | null;
    otel?: {
        authorization: string;
        headers: Record<string, unknown>;
        url: string;
        contentType?: "json" | "protobuf" | (string & {}) | null;
    }[] | null;
    rateLimitingTechnique?: "fixed" | "sliding" | null;
    /** Backoff strategy for retry delays */
    retryBackoff?: "constant" | "linear" | "exponential" | null;
    /** Delay between retry attempts in milliseconds (0-5000) */
    retryDelay?: number | null;
    /** Maximum number of retry attempts for failed requests (1-5) */
    retryMaxAttempts?: number | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | null;
    /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
    workersAiBillingMode?: "postpaid" | null;
    zdr?: boolean | null;
}
export declare const CreateAiGatewayResponse: Schema.Schema<CreateAiGatewayResponse>;
export type CreateAiGatewayError = DefaultErrors | GatewayAlreadyExists;
export declare const createAiGateway: API.OperationMethod<CreateAiGatewayRequest, CreateAiGatewayResponse, CreateAiGatewayError, Credentials | HttpClient.HttpClient>;
export interface UpdateAiGatewayRequest {
    id: string;
    /** Path param */
    accountId: string;
    /** Body param */
    cacheInvalidateOnUpdate: boolean;
    /** Body param */
    cacheTtl: number | null;
    /** Body param */
    collectLogs: boolean;
    /** Body param */
    rateLimitingInterval: number | null;
    /** Body param */
    rateLimitingLimit: number | null;
    /** Body param */
    authentication?: boolean;
    /** Body param */
    dlp?: {
        action: "BLOCK" | "FLAG" | (string & {});
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK" | (string & {});
            check: ("REQUEST" | "RESPONSE" | (string & {}))[];
            enabled: boolean;
            profiles: string[];
        }[];
    };
    /** Body param */
    guardrails?: {
        prompt: {
            p1?: "FLAG" | "BLOCK" | (string & {});
            s1?: "FLAG" | "BLOCK" | (string & {});
            s10?: "FLAG" | "BLOCK" | (string & {});
            s11?: "FLAG" | "BLOCK" | (string & {});
            s12?: "FLAG" | "BLOCK" | (string & {});
            s13?: "FLAG" | "BLOCK" | (string & {});
            s2?: "FLAG" | "BLOCK" | (string & {});
            s3?: "FLAG" | "BLOCK" | (string & {});
            s4?: "FLAG" | "BLOCK" | (string & {});
            s5?: "FLAG" | "BLOCK" | (string & {});
            s6?: "FLAG" | "BLOCK" | (string & {});
            s7?: "FLAG" | "BLOCK" | (string & {});
            s8?: "FLAG" | "BLOCK" | (string & {});
            s9?: "FLAG" | "BLOCK" | (string & {});
        };
        response: {
            p1?: "FLAG" | "BLOCK" | (string & {});
            s1?: "FLAG" | "BLOCK" | (string & {});
            s10?: "FLAG" | "BLOCK" | (string & {});
            s11?: "FLAG" | "BLOCK" | (string & {});
            s12?: "FLAG" | "BLOCK" | (string & {});
            s13?: "FLAG" | "BLOCK" | (string & {});
            s2?: "FLAG" | "BLOCK" | (string & {});
            s3?: "FLAG" | "BLOCK" | (string & {});
            s4?: "FLAG" | "BLOCK" | (string & {});
            s5?: "FLAG" | "BLOCK" | (string & {});
            s6?: "FLAG" | "BLOCK" | (string & {});
            s7?: "FLAG" | "BLOCK" | (string & {});
            s8?: "FLAG" | "BLOCK" | (string & {});
            s9?: "FLAG" | "BLOCK" | (string & {});
        };
    } | null;
    /** Body param */
    logManagement?: number | null;
    /** Body param */
    logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
    /** Body param */
    logpush?: boolean;
    /** Body param */
    logpushPublicKey?: string | null;
    /** Body param */
    otel?: {
        authorization: string;
        headers: Record<string, unknown>;
        url: string;
        contentType?: "json" | "protobuf" | (string & {});
    }[] | null;
    /** Body param */
    rateLimitingTechnique?: "fixed" | "sliding" | null;
    /** Body param: Backoff strategy for retry delays */
    retryBackoff?: "constant" | "linear" | "exponential" | null;
    /** Body param: Delay between retry attempts in milliseconds (0-5000) */
    retryDelay?: number | null;
    /** Body param: Maximum number of retry attempts for failed requests (1-5) */
    retryMaxAttempts?: number | null;
    /** Body param */
    storeId?: string | null;
    /** Body param */
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | null;
    /** Body param: Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
    workersAiBillingMode?: "postpaid";
    /** Body param */
    zdr?: boolean;
}
export declare const UpdateAiGatewayRequest: Schema.Schema<UpdateAiGatewayRequest>;
export interface UpdateAiGatewayResponse {
    /** gateway id */
    id: string;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG" | (string & {});
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK" | (string & {});
            check: ("REQUEST" | "RESPONSE" | (string & {}))[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | null;
    guardrails?: {
        prompt: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
        response: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
    } | null;
    isDefault?: boolean | null;
    logManagement?: number | null;
    logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
    logpush?: boolean | null;
    logpushPublicKey?: string | null;
    otel?: {
        authorization: string;
        headers: Record<string, unknown>;
        url: string;
        contentType?: "json" | "protobuf" | (string & {}) | null;
    }[] | null;
    rateLimitingTechnique?: "fixed" | "sliding" | null;
    /** Backoff strategy for retry delays */
    retryBackoff?: "constant" | "linear" | "exponential" | null;
    /** Delay between retry attempts in milliseconds (0-5000) */
    retryDelay?: number | null;
    /** Maximum number of retry attempts for failed requests (1-5) */
    retryMaxAttempts?: number | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | null;
    /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
    workersAiBillingMode?: "postpaid" | null;
    zdr?: boolean | null;
}
export declare const UpdateAiGatewayResponse: Schema.Schema<UpdateAiGatewayResponse>;
export type UpdateAiGatewayError = DefaultErrors | GatewayNotFound;
export declare const updateAiGateway: API.OperationMethod<UpdateAiGatewayRequest, UpdateAiGatewayResponse, UpdateAiGatewayError, Credentials | HttpClient.HttpClient>;
export interface DeleteAiGatewayRequest {
    id: string;
    accountId: string;
}
export declare const DeleteAiGatewayRequest: Schema.Schema<DeleteAiGatewayRequest>;
export interface DeleteAiGatewayResponse {
    /** gateway id */
    id: string;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG" | (string & {});
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK" | (string & {});
            check: ("REQUEST" | "RESPONSE" | (string & {}))[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | null;
    guardrails?: {
        prompt: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
        response: {
            p1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s1?: "FLAG" | "BLOCK" | (string & {}) | null;
            s10?: "FLAG" | "BLOCK" | (string & {}) | null;
            s11?: "FLAG" | "BLOCK" | (string & {}) | null;
            s12?: "FLAG" | "BLOCK" | (string & {}) | null;
            s13?: "FLAG" | "BLOCK" | (string & {}) | null;
            s2?: "FLAG" | "BLOCK" | (string & {}) | null;
            s3?: "FLAG" | "BLOCK" | (string & {}) | null;
            s4?: "FLAG" | "BLOCK" | (string & {}) | null;
            s5?: "FLAG" | "BLOCK" | (string & {}) | null;
            s6?: "FLAG" | "BLOCK" | (string & {}) | null;
            s7?: "FLAG" | "BLOCK" | (string & {}) | null;
            s8?: "FLAG" | "BLOCK" | (string & {}) | null;
            s9?: "FLAG" | "BLOCK" | (string & {}) | null;
        };
    } | null;
    isDefault?: boolean | null;
    logManagement?: number | null;
    logManagementStrategy?: "STOP_INSERTING" | "DELETE_OLDEST" | null;
    logpush?: boolean | null;
    logpushPublicKey?: string | null;
    otel?: {
        authorization: string;
        headers: Record<string, unknown>;
        url: string;
        contentType?: "json" | "protobuf" | (string & {}) | null;
    }[] | null;
    rateLimitingTechnique?: "fixed" | "sliding" | null;
    /** Backoff strategy for retry delays */
    retryBackoff?: "constant" | "linear" | "exponential" | null;
    /** Delay between retry attempts in milliseconds (0-5000) */
    retryDelay?: number | null;
    /** Maximum number of retry attempts for failed requests (1-5) */
    retryMaxAttempts?: number | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | null;
    /** Controls how Workers AI inference calls routed through this gateway are billed. Only 'postpaid' is currently supported. */
    workersAiBillingMode?: "postpaid" | null;
    zdr?: boolean | null;
}
export declare const DeleteAiGatewayResponse: Schema.Schema<DeleteAiGatewayResponse>;
export type DeleteAiGatewayError = DefaultErrors | GatewayNotFound;
export declare const deleteAiGateway: API.OperationMethod<DeleteAiGatewayRequest, DeleteAiGatewayResponse, DeleteAiGatewayError, Credentials | HttpClient.HttpClient>;
export interface CreditBalanceBillingRequest {
    /** Cloudflare account ID. */
    accountId: string;
}
export declare const CreditBalanceBillingRequest: Schema.Schema<CreditBalanceBillingRequest>;
export interface CreditBalanceBillingResponse {
    balance: number;
    hasDefaultPaymentMethod: boolean;
    paymentMethod: {
        brand?: string | null;
        last4?: string | null;
    } | null;
    topupConfig: {
        amount: number | null;
        disabledReason?: string | null;
        error?: string | null;
        lastFailedAt?: number | null;
        threshold: number | null;
    };
    firstTopupSuccess?: boolean | null;
}
export declare const CreditBalanceBillingResponse: Schema.Schema<CreditBalanceBillingResponse>;
export type CreditBalanceBillingError = DefaultErrors;
export declare const creditBalanceBilling: API.OperationMethod<CreditBalanceBillingRequest, CreditBalanceBillingResponse, CreditBalanceBillingError, Credentials | HttpClient.HttpClient>;
export interface GetBillingSpendingLimitRequest {
    /** Cloudflare account ID. */
    accountId: string;
}
export declare const GetBillingSpendingLimitRequest: Schema.Schema<GetBillingSpendingLimitRequest>;
export interface GetBillingSpendingLimitResponse {
    config: {
        amount: number | null;
        duration: string | null;
        strategy: string | null;
    };
    enabled: boolean;
}
export declare const GetBillingSpendingLimitResponse: Schema.Schema<GetBillingSpendingLimitResponse>;
export type GetBillingSpendingLimitError = DefaultErrors;
export declare const getBillingSpendingLimit: API.OperationMethod<GetBillingSpendingLimitRequest, GetBillingSpendingLimitResponse, GetBillingSpendingLimitError, Credentials | HttpClient.HttpClient>;
export interface CreateBillingSpendingLimitRequest {
    /** Path param: Cloudflare account ID. */
    accountId: string;
    /** Body param: Spending limit amount in cents (min 100). */
    amount: number;
    /** Body param: Spending limit duration. */
    duration: "daily" | "weekly" | "monthly" | (string & {});
    /** Body param: Spending limit strategy. */
    strategy: "fixed" | "sliding" | (string & {});
}
export declare const CreateBillingSpendingLimitRequest: Schema.Schema<CreateBillingSpendingLimitRequest>;
export type CreateBillingSpendingLimitResponse = unknown;
export declare const CreateBillingSpendingLimitResponse: Schema.Schema<CreateBillingSpendingLimitResponse>;
export type CreateBillingSpendingLimitError = DefaultErrors | NoManualTopup;
export declare const createBillingSpendingLimit: API.OperationMethod<CreateBillingSpendingLimitRequest, CreateBillingSpendingLimitResponse, CreateBillingSpendingLimitError, Credentials | HttpClient.HttpClient>;
export interface DeleteBillingSpendingLimitRequest {
    /** Cloudflare account ID. */
    accountId: string;
}
export declare const DeleteBillingSpendingLimitRequest: Schema.Schema<DeleteBillingSpendingLimitRequest>;
export type DeleteBillingSpendingLimitResponse = unknown;
export declare const DeleteBillingSpendingLimitResponse: Schema.Schema<DeleteBillingSpendingLimitResponse>;
export type DeleteBillingSpendingLimitError = DefaultErrors;
export declare const deleteBillingSpendingLimit: API.OperationMethod<DeleteBillingSpendingLimitRequest, DeleteBillingSpendingLimitResponse, DeleteBillingSpendingLimitError, Credentials | HttpClient.HttpClient>;
export interface CreateBillingTopupRequest {
    /** Path param: Cloudflare account ID. */
    accountId: string;
    /** Body param: Top-up amount in cents (min 1000). */
    amount: number;
}
export declare const CreateBillingTopupRequest: Schema.Schema<CreateBillingTopupRequest>;
export interface CreateBillingTopupResponse {
    /** Stripe PaymentIntent client secret. */
    clientSecret: string | null;
    /** Whether the user was already onboarded. */
    onboarding: boolean;
    /** Stripe invoice ID. */
    paymentIntentId: string;
    /** Card brand (visa, mastercard, etc.). */
    brand?: string | null;
    /** Last 4 digits of card. */
    last4?: string | null;
}
export declare const CreateBillingTopupResponse: Schema.Schema<CreateBillingTopupResponse>;
export type CreateBillingTopupError = DefaultErrors;
export declare const createBillingTopup: API.OperationMethod<CreateBillingTopupRequest, CreateBillingTopupResponse, CreateBillingTopupError, Credentials | HttpClient.HttpClient>;
export interface StatusBillingTopupRequest {
    /** Path param: Cloudflare account ID. */
    accountId: string;
    /** Body param: Stripe invoice ID to check status for. */
    paymentIntentId: string;
}
export declare const StatusBillingTopupRequest: Schema.Schema<StatusBillingTopupRequest>;
export interface StatusBillingTopupResponse {
    paymentIntentId: string;
    status: "completed" | "pending" | (string & {});
}
export declare const StatusBillingTopupResponse: Schema.Schema<StatusBillingTopupResponse>;
export type StatusBillingTopupError = DefaultErrors;
export declare const statusBillingTopup: API.OperationMethod<StatusBillingTopupRequest, StatusBillingTopupResponse, StatusBillingTopupError, Credentials | HttpClient.HttpClient>;
export interface GetBillingTopupConfigRequest {
    /** Cloudflare account ID. */
    accountId: string;
}
export declare const GetBillingTopupConfigRequest: Schema.Schema<GetBillingTopupConfigRequest>;
export interface GetBillingTopupConfigResponse {
    amount: number | null;
    disabledReason?: string | null;
    error?: string | null;
    lastFailedAt?: number | null;
    threshold: number | null;
}
export declare const GetBillingTopupConfigResponse: Schema.Schema<GetBillingTopupConfigResponse>;
export type GetBillingTopupConfigError = DefaultErrors;
export declare const getBillingTopupConfig: API.OperationMethod<GetBillingTopupConfigRequest, GetBillingTopupConfigResponse, GetBillingTopupConfigError, Credentials | HttpClient.HttpClient>;
export interface CreateBillingTopupConfigRequest {
    /** Path param: Cloudflare account ID. */
    accountId: string;
    /** Body param: Auto top-up amount in cents (min 1000). */
    amount: number;
    /** Body param: Balance threshold in cents that triggers auto top-up (min 500). */
    threshold: number;
}
export declare const CreateBillingTopupConfigRequest: Schema.Schema<CreateBillingTopupConfigRequest>;
export interface CreateBillingTopupConfigResponse {
    amount: number;
    threshold: number;
}
export declare const CreateBillingTopupConfigResponse: Schema.Schema<CreateBillingTopupConfigResponse>;
export type CreateBillingTopupConfigError = DefaultErrors;
export declare const createBillingTopupConfig: API.OperationMethod<CreateBillingTopupConfigRequest, CreateBillingTopupConfigResponse, CreateBillingTopupConfigError, Credentials | HttpClient.HttpClient>;
export interface DeleteBillingTopupConfigRequest {
    /** Cloudflare account ID. */
    accountId: string;
}
export declare const DeleteBillingTopupConfigRequest: Schema.Schema<DeleteBillingTopupConfigRequest>;
export type DeleteBillingTopupConfigResponse = unknown;
export declare const DeleteBillingTopupConfigResponse: Schema.Schema<DeleteBillingTopupConfigResponse>;
export type DeleteBillingTopupConfigError = DefaultErrors;
export declare const deleteBillingTopupConfig: API.OperationMethod<DeleteBillingTopupConfigRequest, DeleteBillingTopupConfigResponse, DeleteBillingTopupConfigError, Credentials | HttpClient.HttpClient>;
export interface GetDatasetRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const GetDatasetRequest: Schema.Schema<GetDatasetRequest>;
export interface GetDatasetResponse {
    id: string;
    createdAt: string;
    enable: boolean;
    filters: {
        key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
        operator: "eq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | number | boolean)[];
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const GetDatasetResponse: Schema.Schema<GetDatasetResponse>;
export type GetDatasetError = DefaultErrors;
export declare const getDataset: API.OperationMethod<GetDatasetRequest, GetDatasetResponse, GetDatasetError, Credentials | HttpClient.HttpClient>;
export interface ListDatasetsRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param */
    enable?: boolean;
    /** Query param */
    name?: string;
    /** Query param: Search by id, name, filters */
    search?: string;
}
export declare const ListDatasetsRequest: Schema.Schema<ListDatasetsRequest>;
export interface ListDatasetsResponse {
    result: {
        id: string;
        createdAt: string;
        enable: boolean;
        filters: {
            key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
            operator: "eq" | "contains" | "lt" | "gt" | (string & {});
            value: (string | number | boolean)[];
        }[];
        gatewayId: string;
        modifiedAt: string;
        name: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListDatasetsResponse: Schema.Schema<ListDatasetsResponse>;
export type ListDatasetsError = DefaultErrors;
export declare const listDatasets: API.PaginatedOperationMethod<ListDatasetsRequest, ListDatasetsResponse, ListDatasetsError, Credentials | HttpClient.HttpClient>;
export interface CreateDatasetRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    /** Body param */
    enable: boolean;
    /** Body param */
    filters: {
        key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
        operator: "eq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | number | boolean)[];
    }[];
    /** Body param */
    name: string;
}
export declare const CreateDatasetRequest: Schema.Schema<CreateDatasetRequest>;
export interface CreateDatasetResponse {
    id: string;
    createdAt: string;
    enable: boolean;
    filters: {
        key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
        operator: "eq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | number | boolean)[];
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const CreateDatasetResponse: Schema.Schema<CreateDatasetResponse>;
export type CreateDatasetError = DefaultErrors;
export declare const createDataset: API.OperationMethod<CreateDatasetRequest, CreateDatasetResponse, CreateDatasetError, Credentials | HttpClient.HttpClient>;
export interface UpdateDatasetRequest {
    gatewayId: string;
    id: string;
    /** Path param */
    accountId: string;
    /** Body param */
    enable: boolean;
    /** Body param */
    filters: {
        key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
        operator: "eq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | number | boolean)[];
    }[];
    /** Body param */
    name: string;
}
export declare const UpdateDatasetRequest: Schema.Schema<UpdateDatasetRequest>;
export interface UpdateDatasetResponse {
    id: string;
    createdAt: string;
    enable: boolean;
    filters: {
        key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
        operator: "eq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | number | boolean)[];
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const UpdateDatasetResponse: Schema.Schema<UpdateDatasetResponse>;
export type UpdateDatasetError = DefaultErrors;
export declare const updateDataset: API.OperationMethod<UpdateDatasetRequest, UpdateDatasetResponse, UpdateDatasetError, Credentials | HttpClient.HttpClient>;
export interface DeleteDatasetRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const DeleteDatasetRequest: Schema.Schema<DeleteDatasetRequest>;
export interface DeleteDatasetResponse {
    id: string;
    createdAt: string;
    enable: boolean;
    filters: {
        key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
        operator: "eq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | number | boolean)[];
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const DeleteDatasetResponse: Schema.Schema<DeleteDatasetResponse>;
export type DeleteDatasetError = DefaultErrors;
export declare const deleteDataset: API.OperationMethod<DeleteDatasetRequest, DeleteDatasetResponse, DeleteDatasetError, Credentials | HttpClient.HttpClient>;
export interface CreateDeploymentDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    /** Path param */
    accountId: string;
    /** Body param */
    versionId: string;
}
export declare const CreateDeploymentDynamicRoutingRequest: Schema.Schema<CreateDeploymentDynamicRoutingRequest>;
export interface CreateDeploymentDynamicRoutingResponse {
    id: string;
    createdAt: string;
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown | null;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const CreateDeploymentDynamicRoutingResponse: Schema.Schema<CreateDeploymentDynamicRoutingResponse>;
export type CreateDeploymentDynamicRoutingError = DefaultErrors;
export declare const createDeploymentDynamicRouting: API.OperationMethod<CreateDeploymentDynamicRoutingRequest, CreateDeploymentDynamicRoutingResponse, CreateDeploymentDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface ListDeploymentsDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const ListDeploymentsDynamicRoutingRequest: Schema.Schema<ListDeploymentsDynamicRoutingRequest>;
export interface ListDeploymentsDynamicRoutingResponse {
    data: {
        deployments: {
            createdAt: string;
            deploymentId: string;
            versionId: string;
        }[];
        orderBy: string;
        orderByDirection: string;
        page: number;
        perPage: number;
    };
    success: boolean;
}
export declare const ListDeploymentsDynamicRoutingResponse: Schema.Schema<ListDeploymentsDynamicRoutingResponse>;
export type ListDeploymentsDynamicRoutingError = DefaultErrors;
export declare const listDeploymentsDynamicRouting: API.OperationMethod<ListDeploymentsDynamicRoutingRequest, ListDeploymentsDynamicRoutingResponse, ListDeploymentsDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface GetDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const GetDynamicRoutingRequest: Schema.Schema<GetDynamicRoutingRequest>;
export interface GetDynamicRoutingResponse {
    id: string;
    createdAt: string;
    deployment: {
        createdAt: string;
        deploymentId: string;
        versionId: string;
    };
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown | null;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    gatewayId: string;
    modifiedAt: string;
    name: string;
    version: {
        active: true | false;
        createdAt: string;
        data: string;
        versionId: string;
        isValid?: boolean | null;
    };
}
export declare const GetDynamicRoutingResponse: Schema.Schema<GetDynamicRoutingResponse>;
export type GetDynamicRoutingError = DefaultErrors;
export declare const getDynamicRouting: API.OperationMethod<GetDynamicRoutingRequest, GetDynamicRoutingResponse, GetDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface ListDynamicRoutingsRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    /** Query param: Page number */
    page?: number;
    /** Query param: Number of routes per page */
    perPage?: number;
}
export declare const ListDynamicRoutingsRequest: Schema.Schema<ListDynamicRoutingsRequest>;
export interface ListDynamicRoutingsResponse {
    data: {
        orderBy: string;
        orderByDirection: string;
        page: number;
        perPage: number;
        routes: {
            id: string;
            accountTag: string;
            createdAt: string;
            deployment: {
                createdAt: string;
                deploymentId: string;
                versionId: string;
            };
            elements: ({
                id: string;
                outputs: {
                    next: {
                        elementId: string;
                    };
                };
                type: "start";
            } | {
                id: string;
                outputs: {
                    false: {
                        elementId: string;
                    };
                    true: {
                        elementId: string;
                    };
                };
                properties: {
                    conditions?: unknown | null;
                };
                type: "conditional";
            } | {
                id: string;
                outputs: Record<string, unknown>;
                type: "percentage";
            } | {
                id: string;
                outputs: {
                    fallback: {
                        elementId: string;
                    };
                    success: {
                        elementId: string;
                    };
                };
                properties: {
                    key: string;
                    limit: number;
                    limitType: "count" | "cost" | (string & {});
                    window: number;
                };
                type: "rate";
            } | {
                id: string;
                outputs: {
                    fallback: {
                        elementId: string;
                    };
                    success: {
                        elementId: string;
                    };
                };
                properties: {
                    model: string;
                    provider: string;
                    retries: number;
                    timeout: number;
                };
                type: "model";
            } | {
                id: string;
                outputs: Record<string, unknown>;
                type: "end";
            })[];
            gatewayId: string;
            modifiedAt: string;
            name: string;
            version: {
                active: true | false;
                createdAt: string;
                data: string;
                versionId: string;
                isValid?: boolean | null;
            };
        }[];
    };
    success: boolean;
}
export declare const ListDynamicRoutingsResponse: Schema.Schema<ListDynamicRoutingsResponse>;
export type ListDynamicRoutingsError = DefaultErrors;
export declare const listDynamicRoutings: API.OperationMethod<ListDynamicRoutingsRequest, ListDynamicRoutingsResponse, ListDynamicRoutingsError, Credentials | HttpClient.HttpClient>;
export interface CreateDynamicRoutingRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    /** Body param */
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    /** Body param */
    name: string;
}
export declare const CreateDynamicRoutingRequest: Schema.Schema<CreateDynamicRoutingRequest>;
export interface CreateDynamicRoutingResponse {
    id: string;
    createdAt: string;
    deployment: {
        createdAt: string;
        deploymentId: string;
        versionId: string;
    };
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown | null;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    gatewayId: string;
    modifiedAt: string;
    name: string;
    version: {
        active: true | false;
        createdAt: string;
        data: string;
        versionId: string;
        isValid?: boolean | null;
    };
}
export declare const CreateDynamicRoutingResponse: Schema.Schema<CreateDynamicRoutingResponse>;
export type CreateDynamicRoutingError = DefaultErrors;
export declare const createDynamicRouting: API.OperationMethod<CreateDynamicRoutingRequest, CreateDynamicRoutingResponse, CreateDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface PatchDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    /** Path param */
    accountId: string;
    /** Body param */
    name: string;
}
export declare const PatchDynamicRoutingRequest: Schema.Schema<PatchDynamicRoutingRequest>;
export interface PatchDynamicRoutingResponse {
    route: {
        id: string;
        accountTag: string;
        createdAt: string;
        deployment: {
            createdAt: string;
            deploymentId: string;
            versionId: string;
        };
        elements: ({
            id: string;
            outputs: {
                next: {
                    elementId: string;
                };
            };
            type: "start";
        } | {
            id: string;
            outputs: {
                false: {
                    elementId: string;
                };
                true: {
                    elementId: string;
                };
            };
            properties: {
                conditions?: unknown | null;
            };
            type: "conditional";
        } | {
            id: string;
            outputs: Record<string, unknown>;
            type: "percentage";
        } | {
            id: string;
            outputs: {
                fallback: {
                    elementId: string;
                };
                success: {
                    elementId: string;
                };
            };
            properties: {
                key: string;
                limit: number;
                limitType: "count" | "cost" | (string & {});
                window: number;
            };
            type: "rate";
        } | {
            id: string;
            outputs: {
                fallback: {
                    elementId: string;
                };
                success: {
                    elementId: string;
                };
            };
            properties: {
                model: string;
                provider: string;
                retries: number;
                timeout: number;
            };
            type: "model";
        } | {
            id: string;
            outputs: Record<string, unknown>;
            type: "end";
        })[];
        gatewayId: string;
        modifiedAt: string;
        name: string;
        version: {
            active: true | false;
            createdAt: string;
            data: string;
            versionId: string;
            isValid?: boolean | null;
        };
    };
    success: boolean;
}
export declare const PatchDynamicRoutingResponse: Schema.Schema<PatchDynamicRoutingResponse>;
export type PatchDynamicRoutingError = DefaultErrors;
export declare const patchDynamicRouting: API.OperationMethod<PatchDynamicRoutingRequest, PatchDynamicRoutingResponse, PatchDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface DeleteDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const DeleteDynamicRoutingRequest: Schema.Schema<DeleteDynamicRoutingRequest>;
export interface DeleteDynamicRoutingResponse {
    id: string;
    createdAt: string;
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown | null;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const DeleteDynamicRoutingResponse: Schema.Schema<DeleteDynamicRoutingResponse>;
export type DeleteDynamicRoutingError = DefaultErrors;
export declare const deleteDynamicRouting: API.OperationMethod<DeleteDynamicRoutingRequest, DeleteDynamicRoutingResponse, DeleteDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface GetEvaluationRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const GetEvaluationRequest: Schema.Schema<GetEvaluationRequest>;
export interface GetEvaluationResponse {
    id: string;
    createdAt: string;
    datasets: {
        id: string;
        accountId: string;
        accountTag: string;
        createdAt: string;
        enable: boolean;
        filters: {
            key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
            operator: "eq" | "contains" | "lt" | "gt" | (string & {});
            value: (string | number | boolean)[];
        }[];
        gatewayId: string;
        modifiedAt: string;
        name: string;
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
    processed: boolean;
    results: {
        id: string;
        createdAt: string;
        evaluationId: string;
        evaluationTypeId: string;
        modifiedAt: string;
        result: string;
        status: number;
        statusDescription: string;
        totalLogs: number;
    }[];
    totalLogs: number;
}
export declare const GetEvaluationResponse: Schema.Schema<GetEvaluationResponse>;
export type GetEvaluationError = DefaultErrors;
export declare const getEvaluation: API.OperationMethod<GetEvaluationRequest, GetEvaluationResponse, GetEvaluationError, Credentials | HttpClient.HttpClient>;
export interface ListEvaluationsRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param */
    name?: string;
    /** Query param */
    processed?: boolean;
    /** Query param: Search by id, name */
    search?: string;
}
export declare const ListEvaluationsRequest: Schema.Schema<ListEvaluationsRequest>;
export interface ListEvaluationsResponse {
    result: {
        id: string;
        createdAt: string;
        datasets: {
            id: string;
            accountId: string;
            accountTag: string;
            createdAt: string;
            enable: boolean;
            filters: {
                key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
                operator: "eq" | "contains" | "lt" | "gt" | (string & {});
                value: (string | number | boolean)[];
            }[];
            gatewayId: string;
            modifiedAt: string;
            name: string;
        }[];
        gatewayId: string;
        modifiedAt: string;
        name: string;
        processed: boolean;
        results: {
            id: string;
            createdAt: string;
            evaluationId: string;
            evaluationTypeId: string;
            modifiedAt: string;
            result: string;
            status: number;
            statusDescription: string;
            totalLogs: number;
        }[];
        totalLogs: number;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListEvaluationsResponse: Schema.Schema<ListEvaluationsResponse>;
export type ListEvaluationsError = DefaultErrors;
export declare const listEvaluations: API.PaginatedOperationMethod<ListEvaluationsRequest, ListEvaluationsResponse, ListEvaluationsError, Credentials | HttpClient.HttpClient>;
export interface CreateEvaluationRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    /** Body param */
    datasetIds: string[];
    /** Body param */
    evaluationTypeIds: string[];
    /** Body param */
    name: string;
}
export declare const CreateEvaluationRequest: Schema.Schema<CreateEvaluationRequest>;
export interface CreateEvaluationResponse {
    id: string;
    createdAt: string;
    datasets: {
        id: string;
        accountId: string;
        accountTag: string;
        createdAt: string;
        enable: boolean;
        filters: {
            key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
            operator: "eq" | "contains" | "lt" | "gt" | (string & {});
            value: (string | number | boolean)[];
        }[];
        gatewayId: string;
        modifiedAt: string;
        name: string;
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
    processed: boolean;
    results: {
        id: string;
        createdAt: string;
        evaluationId: string;
        evaluationTypeId: string;
        modifiedAt: string;
        result: string;
        status: number;
        statusDescription: string;
        totalLogs: number;
    }[];
    totalLogs: number;
}
export declare const CreateEvaluationResponse: Schema.Schema<CreateEvaluationResponse>;
export type CreateEvaluationError = DefaultErrors;
export declare const createEvaluation: API.OperationMethod<CreateEvaluationRequest, CreateEvaluationResponse, CreateEvaluationError, Credentials | HttpClient.HttpClient>;
export interface DeleteEvaluationRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const DeleteEvaluationRequest: Schema.Schema<DeleteEvaluationRequest>;
export interface DeleteEvaluationResponse {
    id: string;
    createdAt: string;
    datasets: {
        id: string;
        accountId: string;
        accountTag: string;
        createdAt: string;
        enable: boolean;
        filters: {
            key: "created_at" | "request_content_type" | "response_content_type" | "success" | "cached" | "provider" | "model" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
            operator: "eq" | "contains" | "lt" | "gt" | (string & {});
            value: (string | number | boolean)[];
        }[];
        gatewayId: string;
        modifiedAt: string;
        name: string;
    }[];
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    name: string;
    processed: boolean;
    results: {
        id: string;
        createdAt: string;
        evaluationId: string;
        evaluationTypeId: string;
        modifiedAt: string;
        result: string;
        status: number;
        statusDescription: string;
        totalLogs: number;
    }[];
    totalLogs: number;
}
export declare const DeleteEvaluationResponse: Schema.Schema<DeleteEvaluationResponse>;
export type DeleteEvaluationError = DefaultErrors;
export declare const deleteEvaluation: API.OperationMethod<DeleteEvaluationRequest, DeleteEvaluationResponse, DeleteEvaluationError, Credentials | HttpClient.HttpClient>;
export interface ListEvaluationTypesRequest {
    /** Path param */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param */
    orderBy?: string;
    /** Query param */
    orderByDirection?: "asc" | "desc" | (string & {});
}
export declare const ListEvaluationTypesRequest: Schema.Schema<ListEvaluationTypesRequest>;
export interface ListEvaluationTypesResponse {
    result: {
        id: string;
        createdAt: string;
        description: string;
        enable: boolean;
        mandatory: boolean;
        modifiedAt: string;
        name: string;
        type: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListEvaluationTypesResponse: Schema.Schema<ListEvaluationTypesResponse>;
export type ListEvaluationTypesError = DefaultErrors;
export declare const listEvaluationTypes: API.PaginatedOperationMethod<ListEvaluationTypesRequest, ListEvaluationTypesResponse, ListEvaluationTypesError, Credentials | HttpClient.HttpClient>;
export interface InvoiceHistoryBillingRequest {
    /** Path param: Cloudflare account ID. */
    accountId: string;
    /** Query param: Filter invoice type: auto, manual, or all. */
    type?: "auto" | "all" | "manual" | (string & {});
}
export declare const InvoiceHistoryBillingRequest: Schema.Schema<InvoiceHistoryBillingRequest>;
export interface InvoiceHistoryBillingResponse {
    invoices: {
        amountDue: number;
        amountPaid: number;
        amountRemaining: number;
        currency: string;
        id?: string | null;
        attemptCount?: number | null;
        attempted?: boolean | null;
        autoAdvance?: boolean | null;
        created?: number | null;
        createdBy?: string | null;
        description?: string | null;
        invoiceOrigin?: string | null;
        invoicePdf?: string | null;
        status?: string | null;
    }[];
    pagination: {
        hasMore: boolean;
        page: number;
        perPage: number;
        totalCount: number;
    };
}
export declare const InvoiceHistoryBillingResponse: Schema.Schema<InvoiceHistoryBillingResponse>;
export type InvoiceHistoryBillingError = DefaultErrors;
export declare const invoiceHistoryBilling: API.OperationMethod<InvoiceHistoryBillingRequest, InvoiceHistoryBillingResponse, InvoiceHistoryBillingError, Credentials | HttpClient.HttpClient>;
export interface UsageHistoryBillingRequest {
    /** Path param: Cloudflare account ID. */
    accountId: string;
    /** Query param: Grouping window for usage data. */
    valueGroupingWindow: "day" | "hour" | (string & {});
    /** Query param: End time as Unix timestamp in milliseconds. */
    endTime?: number | null;
    /** Query param: Start time as Unix timestamp in milliseconds. */
    startTime?: number | null;
}
export declare const UsageHistoryBillingRequest: Schema.Schema<UsageHistoryBillingRequest>;
export interface UsageHistoryBillingResponse {
    history: {
        id: string;
        aggregatedValue: number;
        endTime: number;
        startTime: number;
    }[];
}
export declare const UsageHistoryBillingResponse: Schema.Schema<UsageHistoryBillingResponse>;
export type UsageHistoryBillingError = DefaultErrors;
export declare const usageHistoryBilling: API.OperationMethod<UsageHistoryBillingRequest, UsageHistoryBillingResponse, UsageHistoryBillingError, Credentials | HttpClient.HttpClient>;
export interface GetLogRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const GetLogRequest: Schema.Schema<GetLogRequest>;
export interface GetLogResponse {
    id: string;
    cached: boolean;
    createdAt: string;
    duration: number;
    model: string;
    path: string;
    provider: string;
    success: boolean;
    tokensIn: number | null;
    tokensOut: number | null;
    cost?: number | null;
    customCost?: boolean | null;
    metadata?: string | null;
    modelType?: string | null;
    requestContentType?: string | null;
    requestHead?: string | null;
    requestHeadComplete?: boolean | null;
    requestSize?: number | null;
    requestType?: string | null;
    responseContentType?: string | null;
    responseHead?: string | null;
    responseHeadComplete?: boolean | null;
    responseSize?: number | null;
    statusCode?: number | null;
    step?: number | null;
}
export declare const GetLogResponse: Schema.Schema<GetLogResponse>;
export type GetLogError = DefaultErrors;
export declare const getLog: API.OperationMethod<GetLogRequest, GetLogResponse, GetLogError, Credentials | HttpClient.HttpClient>;
export interface ListLogsRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    page?: number;
    perPage?: number;
    /** @deprecated Query param */
    cached?: boolean;
    /** @deprecated Query param */
    direction?: "asc" | "desc" | (string & {});
    /** @deprecated Query param */
    endDate?: string;
    /** @deprecated Query param */
    feedback?: "0" | "1" | (string & {});
    /** Query param */
    filters?: {
        key: "id" | "created_at" | "request_content_type" | "response_content_type" | "request_type" | "success" | "cached" | "provider" | "model" | "model_type" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | "event_id" | "metadata.key" | "metadata.value" | "authentication" | "wholesale" | "compatibilityMode" | "dlp_action" | (string & {});
        operator: "eq" | "neq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | null | number | boolean)[];
    }[];
    /** @deprecated Query param */
    maxCost?: number;
    /** @deprecated Query param */
    maxDuration?: number;
    /** @deprecated Query param */
    maxTokensIn?: number;
    /** @deprecated Query param */
    maxTokensOut?: number;
    /** @deprecated Query param */
    maxTotalTokens?: number;
    /** Query param */
    metaInfo?: boolean;
    /** @deprecated Query param */
    minCost?: number;
    /** @deprecated Query param */
    minDuration?: number;
    /** @deprecated Query param */
    minTokensIn?: number;
    /** @deprecated Query param */
    minTokensOut?: number;
    /** @deprecated Query param */
    minTotalTokens?: number;
    /** @deprecated Query param */
    model?: string;
    /** @deprecated Query param */
    modelType?: string;
    /** Query param */
    orderBy?: "created_at" | "provider" | "model" | "model_type" | "success" | "cached" | (string & {});
    /** Query param */
    orderByDirection?: "asc" | "desc" | (string & {});
    /** @deprecated Query param */
    provider?: string;
    /** @deprecated Query param */
    requestContentType?: string;
    /** @deprecated Query param */
    responseContentType?: string;
    /** Query param */
    search?: string;
    /** @deprecated Query param */
    startDate?: string;
    /** @deprecated Query param */
    success?: boolean;
}
export declare const ListLogsRequest: Schema.Schema<ListLogsRequest>;
export interface ListLogsResponse {
    result: {
        id: string;
        cached: boolean;
        createdAt: string;
        duration: number;
        model: string;
        path: string;
        provider: string;
        success: boolean;
        tokensIn: number | null;
        tokensOut: number | null;
        cost?: number | null;
        customCost?: boolean | null;
        metadata?: string | null;
        modelType?: string | null;
        requestContentType?: string | null;
        requestType?: string | null;
        responseContentType?: string | null;
        statusCode?: number | null;
        step?: number | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListLogsResponse: Schema.Schema<ListLogsResponse>;
export type ListLogsError = DefaultErrors;
export declare const listLogs: API.PaginatedOperationMethod<ListLogsRequest, ListLogsResponse, ListLogsError, Credentials | HttpClient.HttpClient>;
export interface PatchLogRequest {
    gatewayId: string;
    id: string;
    /** Path param */
    accountId: string;
    /** Body param */
    feedback?: number | null;
    /** Body param */
    metadata?: Record<string, unknown> | null;
    /** Body param */
    score?: number | null;
}
export declare const PatchLogRequest: Schema.Schema<PatchLogRequest>;
export type PatchLogResponse = unknown;
export declare const PatchLogResponse: Schema.Schema<PatchLogResponse>;
export type PatchLogError = DefaultErrors;
export declare const patchLog: API.OperationMethod<PatchLogRequest, PatchLogResponse, PatchLogError, Credentials | HttpClient.HttpClient>;
export interface DeleteLogRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    /** Query param */
    filters?: {
        key: "id" | "created_at" | "request_content_type" | "response_content_type" | "request_type" | "success" | "cached" | "provider" | "model" | "model_type" | "cost" | "tokens" | "tokens_in" | "tokens_out" | "duration" | "feedback" | "event_id" | "metadata.key" | "metadata.value" | "authentication" | "wholesale" | "compatibilityMode" | "dlp_action" | (string & {});
        operator: "eq" | "neq" | "contains" | "lt" | "gt" | (string & {});
        value: (string | null | number | boolean)[];
    }[];
    /** Query param */
    limit?: number;
    /** Query param */
    orderBy?: "created_at" | "provider" | "model" | "model_type" | "success" | "cached" | "cost" | "tokens_in" | "tokens_out" | "duration" | "feedback" | (string & {});
    /** Query param */
    orderByDirection?: "asc" | "desc" | (string & {});
}
export declare const DeleteLogRequest: Schema.Schema<DeleteLogRequest>;
export interface DeleteLogResponse {
    success: boolean;
}
export declare const DeleteLogResponse: Schema.Schema<DeleteLogResponse>;
export type DeleteLogError = DefaultErrors;
export declare const deleteLog: API.OperationMethod<DeleteLogRequest, DeleteLogResponse, DeleteLogError, Credentials | HttpClient.HttpClient>;
export interface RequestLogRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const RequestLogRequest: Schema.Schema<RequestLogRequest>;
export type RequestLogResponse = unknown;
export declare const RequestLogResponse: Schema.Schema<RequestLogResponse>;
export type RequestLogError = DefaultErrors;
export declare const requestLog: API.OperationMethod<RequestLogRequest, RequestLogResponse, RequestLogError, Credentials | HttpClient.HttpClient>;
export interface ResponseLogRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const ResponseLogRequest: Schema.Schema<ResponseLogRequest>;
export type ResponseLogResponse = unknown;
export declare const ResponseLogResponse: Schema.Schema<ResponseLogResponse>;
export type ResponseLogError = DefaultErrors;
export declare const responseLog: API.OperationMethod<ResponseLogRequest, ResponseLogResponse, ResponseLogError, Credentials | HttpClient.HttpClient>;
export interface InvoicePreviewBillingRequest {
    /** Cloudflare account ID. */
    accountId: string;
}
export declare const InvoicePreviewBillingRequest: Schema.Schema<InvoicePreviewBillingRequest>;
export interface InvoicePreviewBillingResponse {
    id: string;
    amountDue: number;
    amountPaid: number;
    amountRemaining: number;
    currency: string;
    invoiceLines: {
        amount: number;
        currency: string;
        description: string | null;
        period: {
            end: number;
            start: number;
        };
        pricing: {
            unitAmountDecimal: string | null;
        };
        quantity: number;
        pretaxCreditAmounts?: {
            amount: number;
            type: string;
            creditBalanceTransaction?: string | null;
            discount?: string | null;
        }[] | null;
    }[];
    periodEnd: number;
    periodStart: number;
    status: "draft" | "open" | "paid" | "uncollectible" | "void" | (string & {});
}
export declare const InvoicePreviewBillingResponse: Schema.Schema<InvoicePreviewBillingResponse>;
export type InvoicePreviewBillingError = DefaultErrors;
export declare const invoicePreviewBilling: API.OperationMethod<InvoicePreviewBillingRequest, InvoicePreviewBillingResponse, InvoicePreviewBillingError, Credentials | HttpClient.HttpClient>;
export interface ListProviderConfigsRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListProviderConfigsRequest: Schema.Schema<ListProviderConfigsRequest>;
export interface ListProviderConfigsResponse {
    result: {
        id: string;
        alias: string;
        defaultConfig: boolean;
        gatewayId: string;
        modifiedAt: string;
        providerSlug: string;
        secretId: string;
        secretPreview: string;
        rateLimit?: number | null;
        rateLimitPeriod?: number | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListProviderConfigsResponse: Schema.Schema<ListProviderConfigsResponse>;
export type ListProviderConfigsError = DefaultErrors;
export declare const listProviderConfigs: API.PaginatedOperationMethod<ListProviderConfigsRequest, ListProviderConfigsResponse, ListProviderConfigsError, Credentials | HttpClient.HttpClient>;
export interface CreateProviderConfigRequest {
    gatewayId: string;
    /** Path param */
    accountId: string;
    /** Body param */
    alias: string;
    /** Body param */
    defaultConfig: boolean;
    /** Body param */
    providerSlug: string;
    /** Body param */
    secret: string;
    /** Body param */
    secretId: string;
    /** Body param */
    rateLimit?: number;
    /** Body param */
    rateLimitPeriod?: number;
}
export declare const CreateProviderConfigRequest: Schema.Schema<CreateProviderConfigRequest>;
export interface CreateProviderConfigResponse {
    id: string;
    alias: string;
    defaultConfig: boolean;
    /** gateway id */
    gatewayId: string;
    modifiedAt: string;
    providerSlug: string;
    secretId: string;
    secretPreview: string;
    rateLimit?: number | null;
    rateLimitPeriod?: number | null;
}
export declare const CreateProviderConfigResponse: Schema.Schema<CreateProviderConfigResponse>;
export type CreateProviderConfigError = DefaultErrors;
export declare const createProviderConfig: API.OperationMethod<CreateProviderConfigRequest, CreateProviderConfigResponse, CreateProviderConfigError, Credentials | HttpClient.HttpClient>;
export interface GetUrlRequest {
    gatewayId: string;
    provider: string;
    accountId: string;
}
export declare const GetUrlRequest: Schema.Schema<GetUrlRequest>;
export type GetUrlResponse = string;
export declare const GetUrlResponse: Schema.Schema<GetUrlResponse>;
export type GetUrlError = DefaultErrors;
export declare const getUrl: API.OperationMethod<GetUrlRequest, GetUrlResponse, GetUrlError, Credentials | HttpClient.HttpClient>;
export interface GetVersionDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    versionId: string;
    accountId: string;
}
export declare const GetVersionDynamicRoutingRequest: Schema.Schema<GetVersionDynamicRoutingRequest>;
export interface GetVersionDynamicRoutingResponse {
    id: string;
    active: true | false;
    createdAt: string;
    data: string;
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown | null;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    gatewayId: string;
    modifiedAt: string;
    name: string;
    versionId: string;
    isValid?: boolean | null;
}
export declare const GetVersionDynamicRoutingResponse: Schema.Schema<GetVersionDynamicRoutingResponse>;
export type GetVersionDynamicRoutingError = DefaultErrors;
export declare const getVersionDynamicRouting: API.OperationMethod<GetVersionDynamicRoutingRequest, GetVersionDynamicRoutingResponse, GetVersionDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface CreateVersionDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    /** Path param */
    accountId: string;
    /** Body param */
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
}
export declare const CreateVersionDynamicRoutingRequest: Schema.Schema<CreateVersionDynamicRoutingRequest>;
export interface CreateVersionDynamicRoutingResponse {
    id: string;
    createdAt: string;
    elements: ({
        id: string;
        outputs: {
            next: {
                elementId: string;
            };
        };
        type: "start";
    } | {
        id: string;
        outputs: {
            false: {
                elementId: string;
            };
            true: {
                elementId: string;
            };
        };
        properties: {
            conditions?: unknown | null;
        };
        type: "conditional";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "percentage";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            key: string;
            limit: number;
            limitType: "count" | "cost" | (string & {});
            window: number;
        };
        type: "rate";
    } | {
        id: string;
        outputs: {
            fallback: {
                elementId: string;
            };
            success: {
                elementId: string;
            };
        };
        properties: {
            model: string;
            provider: string;
            retries: number;
            timeout: number;
        };
        type: "model";
    } | {
        id: string;
        outputs: Record<string, unknown>;
        type: "end";
    })[];
    gatewayId: string;
    modifiedAt: string;
    name: string;
}
export declare const CreateVersionDynamicRoutingResponse: Schema.Schema<CreateVersionDynamicRoutingResponse>;
export type CreateVersionDynamicRoutingError = DefaultErrors;
export declare const createVersionDynamicRouting: API.OperationMethod<CreateVersionDynamicRoutingRequest, CreateVersionDynamicRoutingResponse, CreateVersionDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export interface ListVersionsDynamicRoutingRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const ListVersionsDynamicRoutingRequest: Schema.Schema<ListVersionsDynamicRoutingRequest>;
export interface ListVersionsDynamicRoutingResponse {
    data: {
        orderBy: string;
        orderByDirection: string;
        page: number;
        perPage: number;
        versions: {
            active: true | false;
            createdAt: string;
            data: string;
            versionId: string;
            isValid?: boolean | null;
        }[];
    };
    success: boolean;
}
export declare const ListVersionsDynamicRoutingResponse: Schema.Schema<ListVersionsDynamicRoutingResponse>;
export type ListVersionsDynamicRoutingError = DefaultErrors;
export declare const listVersionsDynamicRouting: API.OperationMethod<ListVersionsDynamicRoutingRequest, ListVersionsDynamicRoutingResponse, ListVersionsDynamicRoutingError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=ai-gateway.d.ts.map