import { A as Async, E as Exit } from './effect-DbEMiMvv.js';

/**
 * Acquires a resource, uses it, and guarantees release regardless of outcome.
 *
 * - `acquire` runs uninterruptibly (once started, it completes)
 * - `use` runs with the acquired resource
 * - `release` runs after `use` completes (success, failure, or interruption)
 *
 * ```ts
 * const result = bracket(
 *   openConnection(),                    // acquire
 *   (conn) => queryDatabase(conn),       // use
 *   (conn, exit) => conn.close()         // release (always runs)
 * );
 * ```
 */
declare function bracket<R, E, A, B>(acquire: Async<R, E, A>, use: (resource: A) => Async<R, E, B>, release: (resource: A, exit: Exit<E, B>) => Async<R, any, void>): Async<R, E, B>;
/**
 * Runs `effect` and then runs `finalizer` regardless of the outcome.
 * The finalizer receives the exit value for inspection.
 *
 * ```ts
 * const result = ensuring(
 *   doWork(),
 *   (exit) => logCompletion(exit)
 * );
 * ```
 */
declare function ensuring<R, E, A>(effect: Async<R, E, A>, finalizer: (exit: Exit<E, A>) => Async<R, any, void>): Async<R, E, A>;
declare function resource<R, E, A>(acquire: Async<R, E, A>, release: (resource: A, exit: Exit<any, any>) => Async<R, any, void>): Resource<R, E, A>;
declare const makeResource: typeof resource;
declare function resourceSucceed<A>(value: A): Resource<unknown, never, A>;
declare function resourceFromManaged<R, E, A>(m: Managed<R, E, A>): Resource<R, E, A>;
declare function useResource<R, E, A, R2, E2, B>(res: Resource<R, E, A>, body: (resource: A) => Async<R2, E2, B>): Async<R & R2, E | E2, B>;
declare function resourceAll<R, E, Resources extends readonly any[]>(resources: {
    [K in keyof Resources]: Resource<R, E, Resources[K]>;
}): Resource<R, E, Resources>;
/**
 * A Resource describes a scoped value. It is acquired for each `use`, released
 * in LIFO order, and can be composed with `map`, `flatMap`, and `zip`.
 */
type Resource<R, E, A> = {
    readonly _tag: "Resource";
    readonly use: <R2, E2, B>(body: (resource: A) => Async<R2, E2, B>) => Async<R & R2, E | E2, B>;
    readonly map: <B>(f: (resource: A) => B) => Resource<R, E, B>;
    readonly flatMap: <R2, E2, B>(f: (resource: A) => Resource<R2, E2, B>) => Resource<R & R2, E | E2, B>;
    readonly zip: <R2, E2, B>(that: Resource<R2, E2, B>) => Resource<R & R2, E | E2, [A, B]>;
};
declare const Resource: Readonly<{
    make: typeof resource;
    succeed: typeof resourceSucceed;
    fromManaged: typeof resourceFromManaged;
    all: typeof resourceAll;
    use: typeof useResource;
}>;
/**
 * A Managed resource describes how to acquire and release a resource.
 * It can be used multiple times — each `use` call acquires a fresh instance.
 *
 * ```ts
 * const dbPool = managed(
 *   createPool({ max: 10 }),
 *   (pool) => pool.close()
 * );
 *
 * // Use it:
 * const result = useManaged(dbPool, (pool) => pool.query("SELECT 1"));
 * ```
 */
type Managed<R, E, A> = {
    readonly _tag: "Managed";
    readonly acquire: Async<R, E, A>;
    readonly release: (resource: A, exit: Exit<any, any>) => Async<R, any, void>;
};
/**
 * Creates a Managed resource descriptor.
 */
declare function managed<R, E, A>(acquire: Async<R, E, A>, release: (resource: A, exit?: Exit<any, any>) => Async<R, any, void>): Managed<R, E, A>;
/**
 * Uses a Managed resource: acquires, runs the body, and releases.
 */
declare function useManaged<R, E, A, B>(m: Managed<R, E, A>, body: (resource: A) => Async<R, E, B>): Async<R, E, B>;
/**
 * Combines multiple Managed resources. All are acquired in order,
 * and released in reverse order (LIFO).
 *
 * ```ts
 * const resources = managedAll([dbPool, cacheConn, fileHandle]);
 * const result = useManaged(resources, ([db, cache, file]) => ...);
 * ```
 */
declare function managedAll<R, E, Resources extends readonly any[]>(manageds: {
    [K in keyof Resources]: Managed<R, E, Resources[K]>;
}): Managed<R, E, Resources>;

type SpanContext = {
    readonly traceId: string;
    readonly spanId: string;
    readonly parentSpanId?: string;
};
type SpanStatus = "ok" | "error" | "unset";
type Span = {
    readonly name: string;
    readonly context: SpanContext;
    readonly startTime: number;
    endTime?: number;
    status: SpanStatus;
    readonly attributes: Record<string, string | number | boolean>;
    readonly events: SpanEvent[];
};
type SpanEvent = {
    readonly name: string;
    readonly time: number;
    readonly attributes?: Record<string, string | number | boolean>;
};
type TracerConfig = {
    /** Service name for span metadata. */
    readonly serviceName: string;
    /** Called when a span ends (for export). */
    readonly onSpanEnd?: (span: Span) => void;
    /** Sampling rate (0.0 to 1.0). Default: 1.0 (sample everything). */
    readonly sampleRate?: number;
};
type Tracer = {
    /** Wrap an effect in a span. */
    readonly span: <R, E, A>(name: string, effect: Async<R, E, A>, attributes?: Record<string, string | number | boolean>) => Async<R, E, A>;
    /** Get all completed spans (for testing). */
    readonly spans: () => readonly Span[];
    /** Clear collected spans. */
    readonly clear: () => void;
};
/**
 * Creates a tracer that wraps effects in spans.
 *
 * ```ts
 * const tracer = makeTracer({ serviceName: "my-app" });
 *
 * const result = await run(
 *   tracer.span("fetchUser", fetchUser(id), { userId: id })
 * );
 *
 * console.log(tracer.spans()); // all completed spans
 * ```
 */
declare function makeTracer(config: TracerConfig): Tracer;

export { type Managed as M, Resource as R, type Span as S, type Tracer as T, type SpanContext as a, type SpanEvent as b, type SpanStatus as c, type TracerConfig as d, bracket as e, ensuring as f, makeTracer as g, managed as h, managedAll as i, resourceAll as j, resourceFromManaged as k, resourceSucceed as l, makeResource as m, useResource as n, resource as r, useManaged as u };