/**
 * 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 {
}
export interface GetAiGatewayRequest {
    id: string;
    accountId: string;
}
export declare const GetAiGatewayRequest: Schema.Schema<GetAiGatewayRequest>;
export interface GetAiGatewayResponse {
    /** gateway id */
    id: string;
    accountId?: string | null;
    accountTag?: string | null;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    internalId?: string | null;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    rateLimitingTechnique: "fixed" | "sliding";
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG";
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK";
            check: ("REQUEST" | "RESPONSE")[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | 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;
    }[] | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | 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;
        accountId: string;
        accountTag: string;
        cacheInvalidateOnUpdate: boolean;
        cacheTtl: number | null;
        collectLogs: boolean;
        createdAt: string;
        internalId: string;
        modifiedAt: string;
        rateLimitingInterval: number | null;
        rateLimitingLimit: number | null;
        rateLimitingTechnique: "fixed" | "sliding";
        authentication?: boolean | null;
        dlp?: {
            action: "BLOCK" | "FLAG";
            enabled: boolean;
            profiles: string[];
        } | {
            enabled: boolean;
            policies: {
                id: string;
                action: "FLAG" | "BLOCK";
                check: ("REQUEST" | "RESPONSE")[];
                enabled: boolean;
                profiles: string[];
            }[];
        } | 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;
        }[] | null;
        storeId?: string | null;
        stripe?: {
            authorization: string;
            usageEvents: {
                payload: string;
            }[];
        } | 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: */
    rateLimitingTechnique: "fixed" | "sliding";
    /** Body param: */
    authentication?: boolean;
    /** Body param: */
    isDefault?: 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: */
    zdr?: boolean;
}
export declare const CreateAiGatewayRequest: Schema.Schema<CreateAiGatewayRequest>;
export interface CreateAiGatewayResponse {
    /** gateway id */
    id: string;
    accountId?: string | null;
    accountTag?: string | null;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    internalId?: string | null;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    rateLimitingTechnique: "fixed" | "sliding";
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG";
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK";
            check: ("REQUEST" | "RESPONSE")[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | 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;
    }[] | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | 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: */
    rateLimitingTechnique: "fixed" | "sliding";
    /** Body param: */
    authentication?: boolean;
    /** Body param: */
    dlp?: {
        action: "BLOCK" | "FLAG";
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK";
            check: ("REQUEST" | "RESPONSE")[];
            enabled: boolean;
            profiles: string[];
        }[];
    };
    /** Body param: */
    isDefault?: 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: */
    otel?: {
        authorization: string;
        headers: Record<string, unknown>;
        url: string;
    }[] | null;
    /** Body param: */
    storeId?: string | null;
    /** Body param: */
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | null;
    /** Body param: */
    zdr?: boolean;
}
export declare const UpdateAiGatewayRequest: Schema.Schema<UpdateAiGatewayRequest>;
export interface UpdateAiGatewayResponse {
    /** gateway id */
    id: string;
    accountId?: string | null;
    accountTag?: string | null;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    internalId?: string | null;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    rateLimitingTechnique: "fixed" | "sliding";
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG";
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK";
            check: ("REQUEST" | "RESPONSE")[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | 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;
    }[] | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | 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;
    accountId?: string | null;
    accountTag?: string | null;
    cacheInvalidateOnUpdate: boolean;
    cacheTtl: number | null;
    collectLogs: boolean;
    createdAt: string;
    internalId?: string | null;
    modifiedAt: string;
    rateLimitingInterval: number | null;
    rateLimitingLimit: number | null;
    rateLimitingTechnique: "fixed" | "sliding";
    authentication?: boolean | null;
    dlp?: {
        action: "BLOCK" | "FLAG";
        enabled: boolean;
        profiles: string[];
    } | {
        enabled: boolean;
        policies: {
            id: string;
            action: "FLAG" | "BLOCK";
            check: ("REQUEST" | "RESPONSE")[];
            enabled: boolean;
            profiles: string[];
        }[];
    } | 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;
    }[] | null;
    storeId?: string | null;
    stripe?: {
        authorization: string;
        usageEvents: {
            payload: string;
        }[];
    } | 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 GetDatasetRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const GetDatasetRequest: Schema.Schema<GetDatasetRequest>;
export interface GetDatasetResponse {
    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";
        operator: "eq" | "contains" | "lt" | "gt";
        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;
        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";
            operator: "eq" | "contains" | "lt" | "gt";
            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";
        operator: "eq" | "contains" | "lt" | "gt";
        value: (string | number | boolean)[];
    }[];
    /** Body param: */
    name: string;
}
export declare const CreateDatasetRequest: Schema.Schema<CreateDatasetRequest>;
export interface CreateDatasetResponse {
    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";
        operator: "eq" | "contains" | "lt" | "gt";
        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";
        operator: "eq" | "contains" | "lt" | "gt";
        value: (string | number | boolean)[];
    }[];
    /** Body param: */
    name: string;
}
export declare const UpdateDatasetRequest: Schema.Schema<UpdateDatasetRequest>;
export interface UpdateDatasetResponse {
    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";
        operator: "eq" | "contains" | "lt" | "gt";
        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;
    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";
        operator: "eq" | "contains" | "lt" | "gt";
        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 GetEvaluationRequest {
    gatewayId: string;
    id: string;
    accountId: string;
}
export declare const GetEvaluationRequest: Schema.Schema<GetEvaluationRequest>;
export interface GetEvaluationResponse {
    id: string;
    accountId: string;
    accountTag: 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";
            operator: "eq" | "contains" | "lt" | "gt";
            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;
        accountId: string;
        accountTag: 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";
                operator: "eq" | "contains" | "lt" | "gt";
                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;
    accountId: string;
    accountTag: 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";
            operator: "eq" | "contains" | "lt" | "gt";
            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;
    accountId: string;
    accountTag: 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";
            operator: "eq" | "contains" | "lt" | "gt";
            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";
}
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 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";
    /** @deprecated Query param: */
    endDate?: string;
    /** @deprecated Query param: */
    feedback?: "0" | "1";
    /** 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" | "prompts.prompt_id" | "prompts.version_id" | "authentication" | "wholesale" | "compatibilityMode" | "dlp_action";
        operator: "eq" | "neq" | "contains" | "lt" | "gt";
        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";
    /** Query param: */
    orderByDirection?: "asc" | "desc";
    /** @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" | "prompts.prompt_id" | "prompts.version_id" | "authentication" | "wholesale" | "compatibilityMode" | "dlp_action";
        operator: "eq" | "neq" | "contains" | "lt" | "gt";
        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";
    /** Query param: */
    orderByDirection?: "asc" | "desc";
}
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 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 {};
//# sourceMappingURL=ai-gateway.d.ts.map