import type * as RoutesObservability from '../../internal/routes/Observability.js';
import type * as Analytics from '../Analytics.js';
import type * as RequestEvents from './requestEvents.js';
/** Columns of `routes_lifecycle_intervals`: one completed routes stage interval. */
export type Table = {
    /** UTC time when the stage ended. */
    ended_at: string;
    /** Deployment environment that recorded the interval. */
    environment: string;
    /** API-key environment that owns the route journey. */
    routes_environment: 'production' | 'sandbox';
    /** Route method used by the journey. */
    method: 'deposit_address' | 'transaction';
    /** Route provider that owns the journey. */
    provider: string;
    /** UTC time when the interval was recorded. */
    recorded_at: string;
    /** Stable route resource id. */
    resource_id: string;
    /** Service that recorded the interval. */
    service: string;
    /** Completed lifecycle stage. */
    stage: RoutesObservability.LifecycleInterval['stage'];
    /** UTC time when the stage began. */
    started_at: string;
};
/** Discriminated queue event carrying one route lifecycle interval. */
export type Event = {
    /** Stored interval row. */
    data: Table;
    /** Queue event discriminator. */
    type: 'routes:lifecycle:interval';
};
/** Builds a queue sink for completed route lifecycle intervals. */
export declare function createQueueSink(queue: createQueueSink.Queue, options: createQueueSink.Options): createQueueSink.Sink;
export declare namespace createQueueSink {
    /** Context added to every stored interval. */
    type Options = {
        /** Deployment environment that records intervals. */
        environment: string;
        /** Service that records intervals. */
        service: string;
    };
    /** Minimal queue producer used by the interval sink. */
    type Queue = {
        /** Enqueues one lifecycle interval. */
        send(message: Event): Promise<unknown>;
    };
    /** Records one completed route lifecycle interval. */
    type Sink = (interval: RoutesObservability.LifecycleInterval) => Promise<void>;
}
/** Returns whether a queue body is a route lifecycle interval event. */
export declare function isEvent(value: unknown): value is Event;
/** Inserts queued interval rows and applies per-message queue disposition. */
export declare function insertMessages(analytics: Analytics.Analytics, messages: readonly insertMessages.Message[], options?: insertMessages.Options): Promise<void>;
export declare namespace insertMessages {
    /** Minimal queue message carrying one lifecycle event. */
    type Message = {
        /** Acknowledges the message. */
        ack(): void;
        /** Queued lifecycle event. */
        body: Event;
        /** Marks the message for redelivery. */
        retry(): void;
    };
    /** Queue insert observability options. */
    type Options = {
        /** Receives the final insert disposition. */
        onResult?: ((result: RequestEvents.insertMessages.Result) => void) | undefined;
    };
}
//# sourceMappingURL=routesLifecycleIntervals.d.ts.map