import type { HandlerExecutionError, Signer, InboundCodec, CapabilityParser, ParsedCapability, InferInvokedCapability, RevocationChecker, Match, Unit, Result, ConnectionView } from '@ucanto/interface';
import type { ProviderInput } from '@ucanto/server';
import { InvocationConfig } from '@web3-storage/filecoin-client/types';
export * as UcantoInterface from '@ucanto/interface';
export type { Result, Variant } from '@ucanto/interface';
export * from '@web3-storage/filecoin-client/types';
export * from '@web3-storage/capabilities/types';
export interface Queue<Message> {
    add: (message: Message, options?: QueueMessageOptions) => Promise<Result<Unit, QueueAddError>>;
}
export interface Store<RecKey, Rec> {
    /**
     * Puts a record in the store.
     */
    put: (record: Rec) => Promise<Result<Unit, StorePutError>>;
    /**
     * Gets a record from the store.
     */
    get: (key: RecKey) => Promise<Result<Rec, StoreGetError>>;
    /**
     * Determine if a record already exists in the store for the given key.
     */
    has: (key: RecKey) => Promise<Result<boolean, StoreGetError>>;
}
export interface UpdatableStore<RecKey, Rec> {
    /**
     * Updates a record from the store.
     */
    update: (key: RecKey, record: Partial<Rec>) => Promise<Result<Rec, StoreGetError>>;
}
export interface ReadableStreamStore<RecKey, Rec> {
    /**
     * Puts a record in the store.
     */
    put: (record: Rec) => Promise<Result<Unit, StorePutError>>;
    /**
     * Gets a record from the store.
     */
    stream: (key: RecKey) => Promise<Result<ReadableStream<Rec>, StoreGetError>>;
}
export interface ListSuccess<R> {
    /**
     * Opaque string specifying where to start retrival of the next page of
     * results.
     */
    cursor?: string;
    results: R[];
}
export interface Pageable {
    /**
     * Opaque string specifying where to start retrival of the next page of
     * results.
     */
    cursor?: string;
    /**
     * Maximum number of items to return.
     */
    size?: number;
}
export interface QueryableStore<Query, Rec> {
    /**
     * Queries for record matching a given criteria.
     */
    query: (search: Query, options?: Pageable) => Promise<Result<ListSuccess<Rec>, StoreGetError>>;
}
export interface QueueMessageOptions {
    messageGroupId?: string;
}
export interface ServiceConfig<T extends Record<string, any>> {
    connection: ConnectionView<T>;
    invocationConfig: InvocationConfig;
}
export type StorePutError = StoreOperationError | EncodeRecordFailed;
export type StoreGetError = StoreOperationError | EncodeRecordFailed | RecordNotFound;
export type QueueAddError = QueueOperationError | EncodeRecordFailed;
export interface QueueOperationError extends Error {
    name: 'QueueOperationFailed';
}
export interface StoreOperationError extends Error {
    name: 'StoreOperationFailed';
}
export interface RecordNotFound extends Error {
    name: 'RecordNotFound';
}
export interface EncodeRecordFailed extends Error {
    name: 'EncodeRecordFailed';
}
export interface UcantoServerContext extends RevocationChecker {
    id: Signer;
    codec?: InboundCodec;
    errorReporter: ErrorReporter;
}
export interface ErrorReporter {
    catch: (error: HandlerExecutionError) => void;
}
export interface UcantoServerContextTest extends UcantoServerContext {
    queuedMessages: Map<string, unknown[]>;
}
export type Test<S> = (assert: Assert, context: UcantoServerContextTest & S) => unknown;
export type Tests<S> = Record<string, Test<S>>;
export type Input<C extends CapabilityParser<Match<ParsedCapability>>> = ProviderInput<InferInvokedCapability<C> & ParsedCapability>;
export interface Assert {
    equal: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, message?: string) => unknown;
    deepEqual: <Actual, Expected extends Actual>(actual: Actual, expected: Expected, message?: string) => unknown;
    ok: <Actual>(actual: Actual, message?: string) => unknown;
}
//# sourceMappingURL=types.d.ts.map