import type { OperatorContractManifest, OperatorMethodContract } from '@pellux/goodvibes-contracts';
import type { OperatorMethodInput, OperatorMethodOutput, OperatorStreamMethodId, OperatorTypedMethodId } from '@pellux/goodvibes-contracts';
import type { HttpTransport } from '@pellux/goodvibes-transport-http';
import { type ContractInvokeOptions, type ContractStreamOptions, type MethodArgs, type WithoutKeys } from '@pellux/goodvibes-transport-http';
/** Per-call options forwarded to the transport's `invokeContractRoute`. */
export interface OperatorRemoteClientInvokeOptions extends ContractInvokeOptions {
}
/** Per-call options forwarded to the transport's `openContractRouteStream`. */
export interface OperatorRemoteClientStreamOptions extends ContractStreamOptions {
}
/** Internal options for `createOperatorRemoteClient`. */
export interface OperatorRemoteClientOptions {
    /** Factory that maps a method id to its Zod response schema, when available. */
    readonly getResponseSchema?: ((methodId: string) => ContractInvokeOptions['responseSchema']) | undefined;
    /**
     * Applies to JSON request/response methods. Server-sent event stream payloads
     * are validated by their realtime event schemas at the transport boundary.
     *
     * @defaultValue true
     */
    readonly validateResponses?: boolean | undefined;
}
/**
 * Argument tuple for a fully-typed `invoke()` call on a given operator method id.
 * Used internally by the named-method facades (e.g. `sdk.operator.sessions.create`).
 */
export type KnownMethodArgs<TMethodId extends OperatorTypedMethodId> = MethodArgs<OperatorMethodInput<TMethodId>, OperatorRemoteClientInvokeOptions>;
/**
 * Like `KnownMethodArgs` but with some input keys omitted (used for path-parameter
 * methods whose prefix keys are supplied as positional function arguments).
 */
export type KnownPathMethodArgs<TMethodId extends OperatorTypedMethodId, TKeys extends PropertyKey> = MethodArgs<WithoutKeys<OperatorMethodInput<TMethodId>, TKeys>, OperatorRemoteClientInvokeOptions>;
/**
 * Argument tuple for a fully-typed `stream()` call on a given operator stream method id.
 */
export type KnownStreamArgs<TMethodId extends OperatorStreamMethodId> = MethodArgs<OperatorMethodInput<TMethodId>, OperatorRemoteClientStreamOptions>;
/**
 * Low-level operator remote client. Returned by `createOperatorRemoteClient`.
 * Prefer `OperatorSdk` (from `createOperatorSdk`) which adds schema validation
 * and typed method facades.
 */
export interface OperatorRemoteClient {
    /** The underlying HTTP transport used to issue all requests. */
    readonly transport: HttpTransport;
    /** The operator contract manifest describing all available methods and events. */
    readonly contract: OperatorContractManifest;
    /** Return all method descriptors in the operator contract. */
    listOperations(): readonly OperatorMethodContract[];
    /**
     * Look up a contract method descriptor by its string id.
     * @throws `GoodVibesSdkError` when the method id is not in the contract.
     */
    getOperation(methodId: string): OperatorMethodContract;
    invoke<TMethodId extends OperatorTypedMethodId>(methodId: TMethodId, ...args: KnownMethodArgs<TMethodId>): Promise<OperatorMethodOutput<TMethodId>>;
    invoke<T = unknown>(methodId: string, input?: Record<string, unknown>, options?: OperatorRemoteClientInvokeOptions): Promise<T>;
    stream<TMethodId extends OperatorStreamMethodId>(methodId: TMethodId, ...args: KnownStreamArgs<TMethodId>): Promise<() => void>;
    readonly sessions: {
        create(...args: KnownMethodArgs<'sessions.create'>): Promise<OperatorMethodOutput<'sessions.create'>>;
        get(sessionId: string, ...args: KnownPathMethodArgs<'sessions.get', 'sessionId'>): Promise<OperatorMethodOutput<'sessions.get'>>;
        list(...args: KnownMethodArgs<'sessions.list'>): Promise<OperatorMethodOutput<'sessions.list'>>;
        messages: {
            create(sessionId: string, ...args: KnownPathMethodArgs<'sessions.messages.create', 'sessionId'>): Promise<OperatorMethodOutput<'sessions.messages.create'>>;
            list(sessionId: string, ...args: KnownPathMethodArgs<'sessions.messages.list', 'sessionId'>): Promise<OperatorMethodOutput<'sessions.messages.list'>>;
        };
        inputs: {
            cancel(sessionId: string, inputId: string, ...args: KnownPathMethodArgs<'sessions.inputs.cancel', 'sessionId' | 'inputId'>): Promise<OperatorMethodOutput<'sessions.inputs.cancel'>>;
        };
        followUp(...args: KnownMethodArgs<'sessions.followUp'>): Promise<OperatorMethodOutput<'sessions.followUp'>>;
        steer(...args: KnownMethodArgs<'sessions.steer'>): Promise<OperatorMethodOutput<'sessions.steer'>>;
        close(sessionId: string, ...args: KnownPathMethodArgs<'sessions.close', 'sessionId'>): Promise<OperatorMethodOutput<'sessions.close'>>;
        reopen(sessionId: string, ...args: KnownPathMethodArgs<'sessions.reopen', 'sessionId'>): Promise<OperatorMethodOutput<'sessions.reopen'>>;
    };
    readonly tasks: {
        create(...args: KnownMethodArgs<'tasks.create'>): Promise<OperatorMethodOutput<'tasks.create'>>;
        get(taskId: string, ...args: KnownPathMethodArgs<'tasks.get', 'taskId'>): Promise<OperatorMethodOutput<'tasks.get'>>;
        list(...args: KnownMethodArgs<'tasks.list'>): Promise<OperatorMethodOutput<'tasks.list'>>;
        status(...args: KnownMethodArgs<'tasks.status'>): Promise<OperatorMethodOutput<'tasks.status'>>;
        cancel(taskId: string, ...args: KnownPathMethodArgs<'tasks.cancel', 'taskId'>): Promise<OperatorMethodOutput<'tasks.cancel'>>;
        retry(taskId: string, ...args: KnownPathMethodArgs<'tasks.retry', 'taskId'>): Promise<OperatorMethodOutput<'tasks.retry'>>;
    };
    readonly approvals: {
        list(...args: KnownMethodArgs<'approvals.list'>): Promise<OperatorMethodOutput<'approvals.list'>>;
        claim(approvalId: string, ...args: KnownPathMethodArgs<'approvals.claim', 'approvalId'>): Promise<OperatorMethodOutput<'approvals.claim'>>;
        approve(approvalId: string, ...args: KnownPathMethodArgs<'approvals.approve', 'approvalId'>): Promise<OperatorMethodOutput<'approvals.approve'>>;
        deny(approvalId: string, ...args: KnownPathMethodArgs<'approvals.deny', 'approvalId'>): Promise<OperatorMethodOutput<'approvals.deny'>>;
        cancel(approvalId: string, ...args: KnownPathMethodArgs<'approvals.cancel', 'approvalId'>): Promise<OperatorMethodOutput<'approvals.cancel'>>;
    };
    readonly providers: {
        list(...args: KnownMethodArgs<'providers.list'>): Promise<OperatorMethodOutput<'providers.list'>>;
        get(providerId: string, ...args: KnownPathMethodArgs<'providers.get', 'providerId'>): Promise<OperatorMethodOutput<'providers.get'>>;
        usage(providerId: string, ...args: KnownPathMethodArgs<'providers.usage.get', 'providerId'>): Promise<OperatorMethodOutput<'providers.usage.get'>>;
    };
    readonly accounts: {
        snapshot(...args: KnownMethodArgs<'accounts.snapshot'>): Promise<OperatorMethodOutput<'accounts.snapshot'>>;
    };
    readonly localAuth: {
        status(...args: KnownMethodArgs<'local_auth.status'>): Promise<OperatorMethodOutput<'local_auth.status'>>;
    };
    readonly control: {
        snapshot(...args: KnownMethodArgs<'control.snapshot'>): Promise<OperatorMethodOutput<'control.snapshot'>>;
        status(...args: KnownMethodArgs<'control.status'>): Promise<OperatorMethodOutput<'control.status'>>;
        contract(...args: KnownMethodArgs<'control.contract'>): Promise<OperatorMethodOutput<'control.contract'>>;
        methods: {
            list(...args: KnownMethodArgs<'control.methods.list'>): Promise<OperatorMethodOutput<'control.methods.list'>>;
            get(methodId: string, ...args: KnownPathMethodArgs<'control.methods.get', 'methodId'>): Promise<OperatorMethodOutput<'control.methods.get'>>;
        };
        auth: {
            current(...args: KnownMethodArgs<'control.auth.current'>): Promise<OperatorMethodOutput<'control.auth.current'>>;
            login(...args: KnownMethodArgs<'control.auth.login'>): Promise<OperatorMethodOutput<'control.auth.login'>>;
        };
        events: {
            catalog(...args: KnownMethodArgs<'control.events.catalog'>): Promise<OperatorMethodOutput<'control.events.catalog'>>;
            stream(...args: KnownStreamArgs<'control.events.stream'>): Promise<() => void>;
        };
    };
    readonly telemetry: {
        snapshot(...args: KnownMethodArgs<'telemetry.snapshot'>): Promise<OperatorMethodOutput<'telemetry.snapshot'>>;
        events(...args: KnownMethodArgs<'telemetry.events.list'>): Promise<OperatorMethodOutput<'telemetry.events.list'>>;
        errors(...args: KnownMethodArgs<'telemetry.errors.list'>): Promise<OperatorMethodOutput<'telemetry.errors.list'>>;
        traces(...args: KnownMethodArgs<'telemetry.traces.list'>): Promise<OperatorMethodOutput<'telemetry.traces.list'>>;
        metrics(...args: KnownMethodArgs<'telemetry.metrics.get'>): Promise<OperatorMethodOutput<'telemetry.metrics.get'>>;
        otlp: {
            traces(...args: KnownMethodArgs<'telemetry.otlp.traces'>): Promise<OperatorMethodOutput<'telemetry.otlp.traces'>>;
            logs(...args: KnownMethodArgs<'telemetry.otlp.logs'>): Promise<OperatorMethodOutput<'telemetry.otlp.logs'>>;
            metrics(...args: KnownMethodArgs<'telemetry.otlp.metrics'>): Promise<OperatorMethodOutput<'telemetry.otlp.metrics'>>;
        };
        stream(...args: KnownStreamArgs<'telemetry.stream'>): Promise<() => void>;
    };
}
/**
 * Construct a low-level operator remote client from a transport and contract manifest.
 *
 * Typically called by `createOperatorSdk`; use that factory unless you need to
 * supply a custom contract manifest or a non-standard transport.
 *
 * @param transport - The HTTP transport to use for all requests.
 * @param contract - The operator contract manifest.
 * @param clientOptions - Optional response validation settings.
 * @returns An `OperatorRemoteClient` with typed invoke/stream methods.
 */
export declare function createOperatorRemoteClient(transport: HttpTransport, contract: OperatorContractManifest, clientOptions?: OperatorRemoteClientOptions): OperatorRemoteClient;
//# sourceMappingURL=client-core.d.ts.map