import type { IntegrationClientOptions, WritebackResult } from '@relayfile/adapter-core/vfs-client';
import type { PreviewAccess, PreviewParameters, TransportPreviewAction } from './types.js';
export type { EffectPolicyV1, PreviewAccess, PreviewAction, PreviewParameters, PreviewSimulatedReceipt, TransportPreviewAction, } from './types.js';
export type RelayTransportParameters = PreviewParameters;
export interface RelayTransportRequest {
    provider: string;
    resource: string;
    parameters: RelayTransportParameters;
    path: string;
}
export interface RelayTransportWriteRequest extends RelayTransportRequest {
    body: unknown;
}
/**
 * The provider-helper IO boundary. Implementations may use a Relayfile mount,
 * a remote Relayfile API, or a side-effect-free recorder. This type has no
 * Workforce dependency and is safe for runtimes to import directly.
 */
export interface RelayTransport {
    read<T = unknown>(request: RelayTransportRequest): Promise<T>;
    list<T = unknown>(request: RelayTransportRequest): Promise<T[]>;
    write(request: RelayTransportWriteRequest): Promise<WritebackResult>;
}
/** Options accepted by every relay-helper client factory. */
export interface RelayClientOptions extends IntegrationClientOptions {
    /**
     * Explicit helper transport. It takes precedence over mount and HTTP options
     * and over every ambient Relayfile/provider credential during selection. A
     * process write authorizer may still deny or redirect the final write.
     */
    transport?: RelayTransport;
}
export interface PreviewTransportOptions {
    /** Data keyed by canonical Relayfile path for preview reads and lists. */
    fixtures?: Readonly<Record<string, unknown>> | ReadonlyMap<string, unknown>;
    /** Override deterministic fake identifiers when a consumer needs a fixture convention. */
    idFactory?: (request: RelayTransportWriteRequest, sequence: number) => string;
    /** Override deterministic timestamps. Sequence numbers start at one. */
    timestampFactory?: (sequence: number) => string;
}
export { RelayWriteAuthorizationError, bindRelayWriteAuthorizer, runWithRelayWriteAuthorizer, type RelayWriteAuthorizationDecision, type RelayWriteAuthorizer, } from './write-authorizer.js';
/**
 * Side-effect-free provider transport used by local preview and test runs.
 * It never inspects environment variables and never delegates to fetch or the
 * filesystem. Writes are recorded and receive deterministic simulated IDs so
 * later writes can safely refer to earlier ones.
 */
export declare class PreviewTransport implements RelayTransport {
    readonly actions: TransportPreviewAction[];
    readonly accesses: PreviewAccess[];
    private sequence;
    private readonly data;
    private readonly writtenPaths;
    private readonly receiptsByReference;
    private readonly idFactory;
    private readonly timestampFactory;
    constructor(options?: PreviewTransportOptions);
    seed(path: string, value: unknown): this;
    read<T = unknown>(request: RelayTransportRequest): Promise<T>;
    list<T = unknown>(request: RelayTransportRequest): Promise<T[]>;
    write(request: RelayTransportWriteRequest): Promise<WritebackResult>;
    clear(): void;
    private resolveParentReference;
}
/** Return the process-scoped transport used by legacy no-argument clients. */
export declare function getProcessRelayTransport(): RelayTransport | undefined;
/** Set or clear the process-scoped transport used by legacy no-argument clients. */
export declare function setProcessRelayTransport(transport: RelayTransport | undefined): void;
/** Compatibility name used by the preview runtime integration. */
export declare function setPreviewTransport(transport: RelayTransport): void;
/** Clear the process-scoped preview transport. */
export declare function clearPreviewTransport(): void;
/**
 * Bind a process transport and return a restoration callback. Nested bindings
 * restore correctly; the callback will not overwrite a newer binding.
 */
export declare function bindRelayTransport(transport: RelayTransport): () => void;
/** Convenience name for the common process-scoped preview binding. */
export declare const bindPreviewTransport: typeof bindRelayTransport;
/** Explicit constructor injection always wins over the process binding. */
export declare function resolveRelayTransport(options: RelayClientOptions): RelayTransport | undefined;
/**
 * Capture explicit constructor injection while resolving the process binding
 * lazily for every operation. The lazy half is essential for handlers that
 * construct a no-argument client at module load before a Run binds preview.
 */
export declare function createRelayTransportResolver(options: RelayClientOptions): () => RelayTransport | undefined;
//# sourceMappingURL=transport.d.ts.map