import * as PQueue from 'p-queue-compat';
import PQueue__default from 'p-queue-compat';
import * as node_modules_p_queue_compat_dist_types_priority_queue_js from 'node_modules/p-queue-compat/dist/types/priority-queue.js';
import grpc__default, { ClientOptions as ClientOptions$1, CallOptions as CallOptions$1, Metadata, ClientUnaryCall, ClientReadableStream } from '@grpc/grpc-js';
import { UnaryCallback } from '@grpc/grpc-js/build/src/client.js';
import { SubtypeConstructor, ModelInfoRequest, ModelInfoResponse__Output, BatchedGenerationRequest, BatchedGenerationResponse__Output, SingleGenerationRequest, GenerationRequest__Output, BatchedTokenizeRequest, BatchedTokenizeResponse__Output, EmbeddingTasksRequest, EmbeddingResults__Output } from './types.js';
import { Serializable } from '../../internals/serializable.js';
import '@grpc/proto-loader';
import '../../internals/types.js';
import '../../internals/helpers/guards.js';

interface ClientOptions {
    modelRouterSubdomain?: string;
    url: string;
    credentials: {
        rootCert: string;
        certChain: string;
        privateKey: string;
    };
    grpcClientOptions: ClientOptions$1;
    clientShutdownDelay: number;
    limits?: {
        concurrency?: {
            embeddings?: number;
        };
    };
}
type CallOptions = CallOptions$1 & {
    signal?: AbortSignal;
};
type RequiredModel<T> = T & {
    model_id: string;
};
declare class Client extends Serializable {
    readonly options: ClientOptions;
    private usedDefaultCredentials;
    protected getClient<T extends {
        close: () => void;
    }>(modelId: string, factory: SubtypeConstructor<typeof grpc__default.Client, T>): T;
    protected getDefaultCredentials(): {
        rootCert: string;
        privateKey: string;
        certChain: string;
    };
    constructor(options?: Partial<ClientOptions>);
    modelInfo(request: RequiredModel<ModelInfoRequest>, options?: CallOptions): Promise<ModelInfoResponse__Output>;
    generate(request: RequiredModel<BatchedGenerationRequest>, options?: CallOptions): Promise<BatchedGenerationResponse__Output>;
    generateStream(request: RequiredModel<SingleGenerationRequest>, options?: CallOptions): Promise<grpc__default.ClientReadableStream<GenerationRequest__Output>>;
    tokenize(request: RequiredModel<BatchedTokenizeRequest>, options?: CallOptions): Promise<BatchedTokenizeResponse__Output>;
    embed(request: RequiredModel<EmbeddingTasksRequest>, options?: CallOptions): Promise<EmbeddingResults__Output>;
    protected wrapGrpcCall<TRequest, TResponse>(fn: (request: TRequest, metadata: Metadata, options: CallOptions, callback: UnaryCallback<TResponse>) => ClientUnaryCall): (request: TRequest, { signal, ...options }?: CallOptions) => Promise<TResponse>;
    protected wrapGrpcStream<TRequest, TResponse>(fn: (request: TRequest, options: CallOptions) => ClientReadableStream<TResponse>): (request: TRequest, { signal, ...options }?: CallOptions) => Promise<ClientReadableStream<TResponse>>;
    createSnapshot(): {
        options: Omit<ClientOptions, "credentials">;
    };
    loadSnapshot(snapshot: ReturnType<typeof this.createSnapshot>): void;
    protected get queues(): {
        embeddings: PQueue__default<node_modules_p_queue_compat_dist_types_priority_queue_js.default, PQueue.QueueAddOptions>;
    };
}

export { Client };