/**
 * Cloudflare AI API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service ai
 */
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 AccountNotFound_base: Schema.Class<AccountNotFound, Schema.TaggedStruct<"AccountNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class AccountNotFound extends AccountNotFound_base {
}
declare const ModelNotFound_base: Schema.Class<ModelNotFound, Schema.TaggedStruct<"ModelNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class ModelNotFound extends ModelNotFound_base {
}
declare const ModelNotSupported_base: Schema.Class<ModelNotSupported, Schema.TaggedStruct<"ModelNotSupported", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class ModelNotSupported extends ModelNotSupported_base {
}
declare const ModelSchemaNotFound_base: Schema.Class<ModelSchemaNotFound, Schema.TaggedStruct<"ModelSchemaNotFound", {
    readonly code: Schema.Number;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
export declare class ModelSchemaNotFound extends ModelSchemaNotFound_base {
}
export interface RunAiRequest {
    modelName: string;
    /** Path param: */
    accountId: string;
    /** Body param: The text that you want to classify */
    text: string;
}
export declare const RunAiRequest: Schema.Schema<RunAiRequest>;
export type RunAiResponse = {
    label?: string | null;
    score?: number | null;
}[] | File | Blob | {
    audio?: string | null;
} | {
    data?: number[][] | null;
    shape?: number[] | null;
} | {
    text: string;
    vtt?: string | null;
    wordCount?: number | null;
    words?: {
        end?: number | null;
        start?: number | null;
        word?: string | null;
    }[] | null;
} | {
    box?: {
        xmax?: number | null;
        xmin?: number | null;
        ymax?: number | null;
        ymin?: number | null;
    } | null;
    label?: string | null;
    score?: number | null;
}[] | {
    response: string;
    toolCalls?: {
        arguments?: unknown | null;
        name?: string | null;
    }[] | null;
    usage?: {
        completionTokens?: number | null;
        promptTokens?: number | null;
        totalTokens?: number | null;
    } | null;
} | {
    translatedText?: string | null;
} | {
    summary?: string | null;
} | {
    description?: string | null;
};
export declare const RunAiResponse: Schema.Schema<RunAiResponse>;
export type RunAiError = DefaultErrors | ModelNotFound;
export declare const runAi: API.OperationMethod<RunAiRequest, RunAiResponse, RunAiError, Credentials | HttpClient.HttpClient>;
export interface ListAuthorsRequest {
    accountId: string;
}
export declare const ListAuthorsRequest: Schema.Schema<ListAuthorsRequest>;
export interface ListAuthorsResponse {
    result: unknown[];
}
export declare const ListAuthorsResponse: Schema.Schema<ListAuthorsResponse>;
export type ListAuthorsError = DefaultErrors;
export declare const listAuthors: API.PaginatedOperationMethod<ListAuthorsRequest, ListAuthorsResponse, ListAuthorsError, Credentials | HttpClient.HttpClient>;
export interface ListFinetunesRequest {
    accountId: string;
}
export declare const ListFinetunesRequest: Schema.Schema<ListFinetunesRequest>;
export type ListFinetunesResponse = {
    id: string;
    createdAt: string;
    model: string;
    modifiedAt: string;
    name: string;
    description?: string | null;
}[];
export declare const ListFinetunesResponse: Schema.Schema<ListFinetunesResponse>;
export type ListFinetunesError = DefaultErrors | AccountNotFound;
export declare const listFinetunes: API.OperationMethod<ListFinetunesRequest, ListFinetunesResponse, ListFinetunesError, Credentials | HttpClient.HttpClient>;
export interface CreateFinetuneRequest {
    /** Path param: */
    accountId: string;
    /** Body param: */
    model: string;
    /** Body param: */
    name: string;
    /** Body param: */
    description?: string;
    /** Body param: */
    public?: boolean;
}
export declare const CreateFinetuneRequest: Schema.Schema<CreateFinetuneRequest>;
export interface CreateFinetuneResponse {
    id: string;
    createdAt: string;
    model: string;
    modifiedAt: string;
    name: string;
    public: boolean;
    description?: string | null;
}
export declare const CreateFinetuneResponse: Schema.Schema<CreateFinetuneResponse>;
export type CreateFinetuneError = DefaultErrors | ModelNotSupported | AccountNotFound;
export declare const createFinetune: API.OperationMethod<CreateFinetuneRequest, CreateFinetuneResponse, CreateFinetuneError, Credentials | HttpClient.HttpClient>;
export interface CreateFinetuneAssetRequest {
    finetuneId: string;
    /** Path param: */
    accountId: string;
    /** Body param: */
    file?: File | Blob;
    /** Body param: */
    fileName?: string;
}
export declare const CreateFinetuneAssetRequest: Schema.Schema<CreateFinetuneAssetRequest>;
export interface CreateFinetuneAssetResponse {
    success: boolean;
}
export declare const CreateFinetuneAssetResponse: Schema.Schema<CreateFinetuneAssetResponse>;
export type CreateFinetuneAssetError = DefaultErrors | ModelNotSupported | AccountNotFound;
export declare const createFinetuneAsset: API.OperationMethod<CreateFinetuneAssetRequest, CreateFinetuneAssetResponse, CreateFinetuneAssetError, Credentials | HttpClient.HttpClient>;
export interface ListFinetunePublicsRequest {
    /** Path param: */
    accountId: string;
    /** Query param: Pagination Limit */
    limit?: number;
    /** Query param: Pagination Offset */
    offset?: number;
    /** Query param: Order By Column Name */
    orderBy?: string;
}
export declare const ListFinetunePublicsRequest: Schema.Schema<ListFinetunePublicsRequest>;
export interface ListFinetunePublicsResponse {
    result: {
        id: string;
        createdAt: string;
        model: string;
        modifiedAt: string;
        name: string;
        public: boolean;
        description?: string | null;
    }[];
}
export declare const ListFinetunePublicsResponse: Schema.Schema<ListFinetunePublicsResponse>;
export type ListFinetunePublicsError = DefaultErrors;
export declare const listFinetunePublics: API.PaginatedOperationMethod<ListFinetunePublicsRequest, ListFinetunePublicsResponse, ListFinetunePublicsError, Credentials | HttpClient.HttpClient>;
export interface ListModelsRequest {
    /** Path param: */
    accountId: string;
    page?: number;
    perPage?: number;
    /** Query param: Filter by Author */
    author?: string;
    /** Query param: Filter to hide experimental models */
    hideExperimental?: boolean;
    /** Query param: Search */
    search?: string;
    /** Query param: Filter by Source Id */
    source?: number;
    /** Query param: Filter by Task Name */
    task?: string;
}
export declare const ListModelsRequest: Schema.Schema<ListModelsRequest>;
export interface ListModelsResponse {
    result: unknown[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListModelsResponse: Schema.Schema<ListModelsResponse>;
export type ListModelsError = DefaultErrors;
export declare const listModels: API.PaginatedOperationMethod<ListModelsRequest, ListModelsResponse, ListModelsError, Credentials | HttpClient.HttpClient>;
export interface GetModelSchemaRequest {
    /** Path param: */
    accountId: string;
    /** Query param: Model Name */
    model: string;
}
export declare const GetModelSchemaRequest: Schema.Schema<GetModelSchemaRequest>;
export type GetModelSchemaResponse = unknown;
export declare const GetModelSchemaResponse: Schema.Schema<GetModelSchemaResponse>;
export type GetModelSchemaError = DefaultErrors | ModelNotSupported | ModelSchemaNotFound | AccountNotFound;
export declare const getModelSchema: API.OperationMethod<GetModelSchemaRequest, GetModelSchemaResponse, GetModelSchemaError, Credentials | HttpClient.HttpClient>;
export interface ListTasksRequest {
    accountId: string;
}
export declare const ListTasksRequest: Schema.Schema<ListTasksRequest>;
export interface ListTasksResponse {
    result: unknown[];
}
export declare const ListTasksResponse: Schema.Schema<ListTasksResponse>;
export type ListTasksError = DefaultErrors;
export declare const listTasks: API.PaginatedOperationMethod<ListTasksRequest, ListTasksResponse, ListTasksError, Credentials | HttpClient.HttpClient>;
export interface SupportedToMarkdownRequest {
    accountId: string;
}
export declare const SupportedToMarkdownRequest: Schema.Schema<SupportedToMarkdownRequest>;
export interface SupportedToMarkdownResponse {
    result: {
        extension: string;
        mimeType: string;
    }[];
}
export declare const SupportedToMarkdownResponse: Schema.Schema<SupportedToMarkdownResponse>;
export type SupportedToMarkdownError = DefaultErrors;
export declare const supportedToMarkdown: API.PaginatedOperationMethod<SupportedToMarkdownRequest, SupportedToMarkdownResponse, SupportedToMarkdownError, Credentials | HttpClient.HttpClient>;
export interface TransformToMarkdownRequest {
    /** Path param: */
    accountId: string;
}
export declare const TransformToMarkdownRequest: Schema.Schema<TransformToMarkdownRequest>;
export interface TransformToMarkdownResponse {
    result: {
        data: string;
        format: string;
        mimeType: string;
        name: string;
        tokens: string;
    }[];
}
export declare const TransformToMarkdownResponse: Schema.Schema<TransformToMarkdownResponse>;
export type TransformToMarkdownError = DefaultErrors;
export declare const transformToMarkdown: API.PaginatedOperationMethod<TransformToMarkdownRequest, TransformToMarkdownResponse, TransformToMarkdownError, Credentials | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=ai.d.ts.map