import * as Effect from 'effect/Effect';
import * as Schema from 'effect/Schema';
import { Operation, type OperationInvoker, OperationResolver } from '@dxos/operation';
export declare const Compute: Omit<{
    readonly schema: {
        readonly input: Schema.Struct<{
            value: typeof Schema.Number;
        }>;
        readonly output: Schema.Struct<{
            value: typeof Schema.Number;
        }>;
    };
    readonly meta: {
        readonly key: "test.compute";
    };
}, "executionMode"> & import("effect/Pipeable").Pipeable & {
    readonly executionMode: "sync" | "async";
};
export declare const HalveCompute: Omit<{
    readonly schema: {
        readonly input: Schema.Struct<{
            value: typeof Schema.Number;
        }>;
        readonly output: Schema.Struct<{
            value: typeof Schema.Number;
        }>;
    };
    readonly meta: {
        readonly key: "test.halve-compute";
    };
}, "executionMode"> & import("effect/Pipeable").Pipeable & {
    readonly executionMode: "sync" | "async";
};
export declare const ToString: Omit<{
    readonly schema: {
        readonly input: Schema.Struct<{
            value: typeof Schema.Number;
        }>;
        readonly output: Schema.Struct<{
            string: typeof Schema.String;
        }>;
    };
    readonly meta: {
        readonly key: "test.to-string";
    };
}, "executionMode"> & import("effect/Pipeable").Pipeable & {
    readonly executionMode: "sync" | "async";
};
export declare const Add: Omit<{
    readonly schema: {
        readonly input: Schema.Tuple2<typeof Schema.Number, typeof Schema.Number>;
        readonly output: typeof Schema.Number;
    };
    readonly meta: {
        readonly key: "test.add";
    };
}, "executionMode"> & import("effect/Pipeable").Pipeable & {
    readonly executionMode: "sync" | "async";
};
export declare const SideEffect: Omit<{
    readonly schema: {
        readonly input: typeof Schema.Void;
        readonly output: typeof Schema.Void;
    };
    readonly meta: {
        readonly key: "test.side-effect";
    };
}, "executionMode"> & import("effect/Pipeable").Pipeable & {
    readonly executionMode: "sync" | "async";
};
export declare const computeHandler: OperationResolver.OperationResolver<{
    readonly value: number;
}, {
    readonly value: number;
}, never, Operation.Service>;
export declare const halveComputeHandler: OperationResolver.OperationResolver<{
    readonly value: number;
}, {
    readonly value: number;
}, never, Operation.Service>;
export declare const toStringHandler: OperationResolver.OperationResolver<{
    readonly value: number;
}, {
    readonly string: string;
}, never, Operation.Service>;
export declare const addHandler: OperationResolver.OperationResolver<readonly [number, number], number, never, Operation.Service>;
export declare const sideEffectHandler: OperationResolver.OperationResolver<void, void, never, Operation.Service>;
/**
 * Event collector for testing - provides deterministic event collection using Effect primitives.
 */
export interface EventCollector {
    /** All collected events. */
    readonly events: OperationInvoker.InvocationEvent[];
    /** Wait until N events have been collected. */
    waitForEvents: (count: number) => Effect.Effect<void>;
    /** Clean up the subscription fiber. */
    dispose: Effect.Effect<void>;
}
/**
 * Creates an event collector that subscribes to invoker events.
 * Uses Effect primitives for synchronization.
 */
export declare const createEventCollector: (invoker: OperationInvoker.OperationInvoker) => Effect.Effect<EventCollector>;
/**
 * Waits until a condition is true, yielding to the JS event loop between checks.
 * Uses setImmediate to allow other async work to complete.
 */
export declare const waitUntil: (condition: () => boolean) => Effect.Effect<void>;
//# sourceMappingURL=testing.d.ts.map