@delmaredigital/payload-experiments 0.0.0-stage → 0.1.0-rc.3

package/dist/db/names.d.ts

@@ -0,0 +1,271 @@
+/** SQL identifiers from the Payload 3.90.2 generated-schema fixture (2026-10-30).
+ * All main, array, relationship and version tables are included. Access through
+ * these literal keys is checked by TypeScript; names.test.ts checks fixture parity.
+ */
+export declare const TABLES: {
+    readonly experimentsTargeting: "xp_experiments_targeting";
+    readonly experimentsArms: "xp_experiments_arms";
+    readonly experiments: "xp_experiments";
+    readonly experimentsRels: "xp_experiments_rels";
+    readonly experimentsVersionsVersionTargeting: "_xp_experiments_v_version_targeting";
+    readonly experimentsVersionsVersionArms: "_xp_experiments_v_version_arms";
+    readonly experimentsVersions: "_xp_experiments_v";
+    readonly experimentsVersionsRels: "_xp_experiments_v_rels";
+    readonly phases: "xp_phases";
+    readonly layers: "xp_layers";
+    readonly metrics: "xp_metrics";
+    readonly events: "xp_events";
+    readonly identities: "xp_identities";
+    readonly resultsSnapshots: "xp_results_snapshots";
+    readonly state: "xp_state";
+};
+export declare const COLUMNS: {
+    readonly state: {
+        readonly id: "id";
+        readonly revision: "revision";
+        readonly manifest: "manifest";
+        readonly flagDefaults: "flag_defaults";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly experimentsTargeting: {
+        readonly _order: "_order";
+        readonly _parentId: "_parent_id";
+        readonly id: "id";
+        readonly attribute: "attribute";
+        readonly op: "op";
+        readonly value: "value";
+    };
+    readonly experimentsArms: {
+        readonly _order: "_order";
+        readonly _parentId: "_parent_id";
+        readonly id: "id";
+        readonly key: "key";
+        readonly label: "label";
+        readonly weight: "weight";
+        readonly kind: "kind";
+        readonly slot: "slot";
+        readonly params: "params";
+        readonly pageTarget: "page_target";
+    };
+    readonly experiments: {
+        readonly id: "id";
+        readonly status: "status";
+        readonly name: "name";
+        readonly slug: "slug";
+        readonly hypothesis: "hypothesis";
+        readonly kind: "kind";
+        readonly flagPoint: "flag_point";
+        readonly exposurePolicy: "exposure_policy";
+        readonly unitType: "unit_type";
+        readonly allocation: "allocation";
+        readonly layerId: "layer_id";
+        readonly metricsPrimaryId: "metrics_primary_id";
+        readonly analysisMethod: "analysis_method";
+        readonly analysisCuped: "analysis_cuped";
+        readonly analysisMinExposuresPerArm: "analysis_min_exposures_per_arm";
+        readonly analysisPlannedDurationDays: "analysis_planned_duration_days";
+        readonly analysisAttributionWindowHours: "analysis_attribution_window_hours";
+        readonly analysisSequentialTuningParameter: "analysis_sequential_tuning_parameter";
+        readonly analysisReachPerDay: "analysis_reach_per_day";
+        readonly layerSlices: "layer_slices";
+        readonly phase: "phase";
+        readonly seed: "seed";
+        readonly startedAt: "started_at";
+        readonly stoppedAt: "stopped_at";
+        readonly decidedAt: "decided_at";
+        readonly archivedAt: "archived_at";
+        readonly decisionWinnerArm: "decision_winner_arm";
+        readonly decisionVerdictCode: "decision_verdict_code";
+        readonly decisionNote: "decision_note";
+        readonly decisionDecidedBy: "decision_decided_by";
+        readonly decisionSnapshotId: "decision_snapshot_id";
+        readonly decisionDiscardedAt: "decision_discarded_at";
+        readonly decisionContentReport: "decision_content_report";
+        readonly decisionHoldoutReleasedAt: "decision_holdout_released_at";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly experimentsRels: {
+        readonly id: "id";
+        readonly order: "order";
+        readonly parentId: "parent_id";
+        readonly path: "path";
+        readonly xpMetricsId: "xp_metrics_id";
+    };
+    readonly experimentsVersionsVersionTargeting: {
+        readonly _order: "_order";
+        readonly _parentId: "_parent_id";
+        readonly id: "id";
+        readonly attribute: "attribute";
+        readonly op: "op";
+        readonly value: "value";
+        readonly _uuid: "_uuid";
+    };
+    readonly experimentsVersionsVersionArms: {
+        readonly _order: "_order";
+        readonly _parentId: "_parent_id";
+        readonly id: "id";
+        readonly key: "key";
+        readonly label: "label";
+        readonly weight: "weight";
+        readonly kind: "kind";
+        readonly slot: "slot";
+        readonly params: "params";
+        readonly pageTarget: "page_target";
+        readonly _uuid: "_uuid";
+    };
+    readonly experimentsVersions: {
+        readonly id: "id";
+        readonly parentId: "parent_id";
+        readonly versionStatus: "version_status";
+        readonly versionName: "version_name";
+        readonly versionSlug: "version_slug";
+        readonly versionHypothesis: "version_hypothesis";
+        readonly versionKind: "version_kind";
+        readonly versionFlagPoint: "version_flag_point";
+        readonly versionExposurePolicy: "version_exposure_policy";
+        readonly versionUnitType: "version_unit_type";
+        readonly versionAllocation: "version_allocation";
+        readonly versionLayerId: "version_layer_id";
+        readonly versionMetricsPrimaryId: "version_metrics_primary_id";
+        readonly versionAnalysisMethod: "version_analysis_method";
+        readonly versionAnalysisCuped: "version_analysis_cuped";
+        readonly versionAnalysisMinExposuresPerArm: "version_analysis_min_exposures_per_arm";
+        readonly versionAnalysisPlannedDurationDays: "version_analysis_planned_duration_days";
+        readonly versionAnalysisAttributionWindowHours: "version_analysis_attribution_window_hours";
+        readonly versionAnalysisSequentialTuningParameter: "version_analysis_sequential_tuning_parameter";
+        readonly versionAnalysisReachPerDay: "version_analysis_reach_per_day";
+        readonly versionLayerSlices: "version_layer_slices";
+        readonly versionPhase: "version_phase";
+        readonly versionSeed: "version_seed";
+        readonly versionStartedAt: "version_started_at";
+        readonly versionStoppedAt: "version_stopped_at";
+        readonly versionDecidedAt: "version_decided_at";
+        readonly versionArchivedAt: "version_archived_at";
+        readonly versionDecisionWinnerArm: "version_decision_winner_arm";
+        readonly versionDecisionVerdictCode: "version_decision_verdict_code";
+        readonly versionDecisionNote: "version_decision_note";
+        readonly versionDecisionDecidedBy: "version_decision_decided_by";
+        readonly versionDecisionSnapshotId: "version_decision_snapshot_id";
+        readonly versionDecisionDiscardedAt: "version_decision_discarded_at";
+        readonly versionDecisionContentReport: "version_decision_content_report";
+        readonly versionDecisionHoldoutReleasedAt: "version_decision_holdout_released_at";
+        readonly versionUpdatedAt: "version_updated_at";
+        readonly versionCreatedAt: "version_created_at";
+        readonly createdAt: "created_at";
+        readonly updatedAt: "updated_at";
+    };
+    readonly experimentsVersionsRels: {
+        readonly id: "id";
+        readonly order: "order";
+        readonly parentId: "parent_id";
+        readonly path: "path";
+        readonly xpMetricsId: "xp_metrics_id";
+    };
+    readonly phases: {
+        readonly id: "id";
+        readonly experimentId: "experiment_id";
+        readonly phase: "phase";
+        readonly phaseKind: "phase_kind";
+        readonly startedAt: "started_at";
+        readonly endedAt: "ended_at";
+        readonly seed: "seed";
+        readonly arms: "arms";
+        readonly allocation: "allocation";
+        readonly allocationChanges: "allocation_changes";
+        readonly targeting: "targeting";
+        readonly metricDefinitions: "metric_definitions";
+        readonly analysis: "analysis";
+        readonly contentChanges: "content_changes";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly layers: {
+        readonly id: "id";
+        readonly name: "name";
+        readonly slug: "slug";
+        readonly unitType: "unit_type";
+        readonly description: "description";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly metrics: {
+        readonly id: "id";
+        readonly name: "name";
+        readonly slug: "slug";
+        readonly source: "source";
+        readonly direction: "direction";
+        readonly attributionWindowHours: "attribution_window_hours";
+        readonly cappingType: "capping_type";
+        readonly cappingValue: "capping_value";
+        readonly minSampleSize: "min_sample_size";
+        readonly guardrailThreshold: "guardrail_threshold";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly events: {
+        readonly id: "id";
+        readonly type: "type";
+        readonly experimentId: "experiment_id";
+        readonly phase: "phase";
+        readonly arm: "arm";
+        readonly unitId: "unit_id";
+        readonly unitType: "unit_type";
+        readonly userId: "user_id";
+        readonly eventName: "event_name";
+        readonly value: "value";
+        readonly ts: "ts";
+        readonly dimensions: "dimensions";
+        readonly attributes: "attributes";
+        readonly dedupeKey: "dedupe_key";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly identities: {
+        readonly id: "id";
+        readonly anonymousId: "anonymous_id";
+        readonly userId: "user_id";
+        readonly linkedAt: "linked_at";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+    readonly resultsSnapshots: {
+        readonly id: "id";
+        readonly experimentId: "experiment_id";
+        readonly phase: "phase";
+        readonly computedAt: "computed_at";
+        readonly window: "window";
+        readonly snapshot: "snapshot";
+        readonly updatedAt: "updated_at";
+        readonly createdAt: "created_at";
+    };
+};
+export declare const ENUMS: {
+    readonly experimentsTargetingOp: "enum_xp_experiments_targeting_op";
+    readonly experimentsArmsKey: "enum_xp_experiments_arms_key";
+    readonly experimentsArmsKind: "enum_xp_experiments_arms_kind";
+    readonly experimentsArmsSlot: "enum_xp_experiments_arms_slot";
+    readonly experimentsStatus: "enum_xp_experiments_status";
+    readonly experimentsKind: "enum_xp_experiments_kind";
+    readonly experimentsExposurePolicy: "enum_xp_experiments_exposure_policy";
+    readonly experimentsUnitType: "enum_xp_experiments_unit_type";
+    readonly experimentsAnalysisMethod: "enum_xp_experiments_analysis_method";
+    readonly experimentsAnalysisCuped: "enum_xp_experiments_analysis_cuped";
+    readonly experimentsVersionsVersionTargetingOp: "enum__xp_experiments_v_version_targeting_op";
+    readonly experimentsVersionsVersionArmsKey: "enum__xp_experiments_v_version_arms_key";
+    readonly experimentsVersionsVersionArmsKind: "enum__xp_experiments_v_version_arms_kind";
+    readonly experimentsVersionsVersionArmsSlot: "enum__xp_experiments_v_version_arms_slot";
+    readonly experimentsVersionsVersionStatus: "enum__xp_experiments_v_version_status";
+    readonly experimentsVersionsVersionKind: "enum__xp_experiments_v_version_kind";
+    readonly experimentsVersionsVersionExposurePolicy: "enum__xp_experiments_v_version_exposure_policy";
+    readonly experimentsVersionsVersionUnitType: "enum__xp_experiments_v_version_unit_type";
+    readonly experimentsVersionsVersionAnalysisMethod: "enum__xp_experiments_v_version_analysis_method";
+    readonly experimentsVersionsVersionAnalysisCuped: "enum__xp_experiments_v_version_analysis_cuped";
+    readonly phasesPhaseKind: "enum_xp_phases_phase_kind";
+    readonly layersUnitType: "enum_xp_layers_unit_type";
+    readonly metricsDirection: "enum_xp_metrics_direction";
+    readonly metricsCappingType: "enum_xp_metrics_capping_type";
+    readonly eventsType: "enum_xp_events_type";
+    readonly eventsUnitType: "enum_xp_events_unit_type";
+};

package/dist/db/names.js

@@ -0,0 +1,270 @@
+/** SQL identifiers from the Payload 3.90.2 generated-schema fixture (2026-10-30).
+ * All main, array, relationship and version tables are included. Access through
+ * these literal keys is checked by TypeScript; names.test.ts checks fixture parity.
+ */ export const TABLES = {
+    experimentsTargeting: 'xp_experiments_targeting',
+    experimentsArms: 'xp_experiments_arms',
+    experiments: 'xp_experiments',
+    experimentsRels: 'xp_experiments_rels',
+    experimentsVersionsVersionTargeting: '_xp_experiments_v_version_targeting',
+    experimentsVersionsVersionArms: '_xp_experiments_v_version_arms',
+    experimentsVersions: '_xp_experiments_v',
+    experimentsVersionsRels: '_xp_experiments_v_rels',
+    phases: 'xp_phases',
+    layers: 'xp_layers',
+    metrics: 'xp_metrics',
+    events: 'xp_events',
+    identities: 'xp_identities',
+    resultsSnapshots: 'xp_results_snapshots',
+    state: 'xp_state'
+};
+export const COLUMNS = {
+    state: {
+        id: 'id',
+        revision: 'revision',
+        manifest: 'manifest',
+        flagDefaults: 'flag_defaults',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    experimentsTargeting: {
+        _order: '_order',
+        _parentId: '_parent_id',
+        id: 'id',
+        attribute: 'attribute',
+        op: 'op',
+        value: 'value'
+    },
+    experimentsArms: {
+        _order: '_order',
+        _parentId: '_parent_id',
+        id: 'id',
+        key: 'key',
+        label: 'label',
+        weight: 'weight',
+        kind: 'kind',
+        slot: 'slot',
+        params: 'params',
+        pageTarget: 'page_target'
+    },
+    experiments: {
+        id: 'id',
+        status: 'status',
+        name: 'name',
+        slug: 'slug',
+        hypothesis: 'hypothesis',
+        kind: 'kind',
+        flagPoint: 'flag_point',
+        exposurePolicy: 'exposure_policy',
+        unitType: 'unit_type',
+        allocation: 'allocation',
+        layerId: 'layer_id',
+        metricsPrimaryId: 'metrics_primary_id',
+        analysisMethod: 'analysis_method',
+        analysisCuped: 'analysis_cuped',
+        analysisMinExposuresPerArm: 'analysis_min_exposures_per_arm',
+        analysisPlannedDurationDays: 'analysis_planned_duration_days',
+        analysisAttributionWindowHours: 'analysis_attribution_window_hours',
+        analysisSequentialTuningParameter: 'analysis_sequential_tuning_parameter',
+        analysisReachPerDay: 'analysis_reach_per_day',
+        layerSlices: 'layer_slices',
+        phase: 'phase',
+        seed: 'seed',
+        startedAt: 'started_at',
+        stoppedAt: 'stopped_at',
+        decidedAt: 'decided_at',
+        archivedAt: 'archived_at',
+        decisionWinnerArm: 'decision_winner_arm',
+        decisionVerdictCode: 'decision_verdict_code',
+        decisionNote: 'decision_note',
+        decisionDecidedBy: 'decision_decided_by',
+        decisionSnapshotId: 'decision_snapshot_id',
+        decisionDiscardedAt: 'decision_discarded_at',
+        decisionContentReport: 'decision_content_report',
+        decisionHoldoutReleasedAt: 'decision_holdout_released_at',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    experimentsRels: {
+        id: 'id',
+        order: 'order',
+        parentId: 'parent_id',
+        path: 'path',
+        xpMetricsId: 'xp_metrics_id'
+    },
+    experimentsVersionsVersionTargeting: {
+        _order: '_order',
+        _parentId: '_parent_id',
+        id: 'id',
+        attribute: 'attribute',
+        op: 'op',
+        value: 'value',
+        _uuid: '_uuid'
+    },
+    experimentsVersionsVersionArms: {
+        _order: '_order',
+        _parentId: '_parent_id',
+        id: 'id',
+        key: 'key',
+        label: 'label',
+        weight: 'weight',
+        kind: 'kind',
+        slot: 'slot',
+        params: 'params',
+        pageTarget: 'page_target',
+        _uuid: '_uuid'
+    },
+    experimentsVersions: {
+        id: 'id',
+        parentId: 'parent_id',
+        versionStatus: 'version_status',
+        versionName: 'version_name',
+        versionSlug: 'version_slug',
+        versionHypothesis: 'version_hypothesis',
+        versionKind: 'version_kind',
+        versionFlagPoint: 'version_flag_point',
+        versionExposurePolicy: 'version_exposure_policy',
+        versionUnitType: 'version_unit_type',
+        versionAllocation: 'version_allocation',
+        versionLayerId: 'version_layer_id',
+        versionMetricsPrimaryId: 'version_metrics_primary_id',
+        versionAnalysisMethod: 'version_analysis_method',
+        versionAnalysisCuped: 'version_analysis_cuped',
+        versionAnalysisMinExposuresPerArm: 'version_analysis_min_exposures_per_arm',
+        versionAnalysisPlannedDurationDays: 'version_analysis_planned_duration_days',
+        versionAnalysisAttributionWindowHours: 'version_analysis_attribution_window_hours',
+        versionAnalysisSequentialTuningParameter: 'version_analysis_sequential_tuning_parameter',
+        versionAnalysisReachPerDay: 'version_analysis_reach_per_day',
+        versionLayerSlices: 'version_layer_slices',
+        versionPhase: 'version_phase',
+        versionSeed: 'version_seed',
+        versionStartedAt: 'version_started_at',
+        versionStoppedAt: 'version_stopped_at',
+        versionDecidedAt: 'version_decided_at',
+        versionArchivedAt: 'version_archived_at',
+        versionDecisionWinnerArm: 'version_decision_winner_arm',
+        versionDecisionVerdictCode: 'version_decision_verdict_code',
+        versionDecisionNote: 'version_decision_note',
+        versionDecisionDecidedBy: 'version_decision_decided_by',
+        versionDecisionSnapshotId: 'version_decision_snapshot_id',
+        versionDecisionDiscardedAt: 'version_decision_discarded_at',
+        versionDecisionContentReport: 'version_decision_content_report',
+        versionDecisionHoldoutReleasedAt: 'version_decision_holdout_released_at',
+        versionUpdatedAt: 'version_updated_at',
+        versionCreatedAt: 'version_created_at',
+        createdAt: 'created_at',
+        updatedAt: 'updated_at'
+    },
+    experimentsVersionsRels: {
+        id: 'id',
+        order: 'order',
+        parentId: 'parent_id',
+        path: 'path',
+        xpMetricsId: 'xp_metrics_id'
+    },
+    phases: {
+        id: 'id',
+        experimentId: 'experiment_id',
+        phase: 'phase',
+        phaseKind: 'phase_kind',
+        startedAt: 'started_at',
+        endedAt: 'ended_at',
+        seed: 'seed',
+        arms: 'arms',
+        allocation: 'allocation',
+        allocationChanges: 'allocation_changes',
+        targeting: 'targeting',
+        metricDefinitions: 'metric_definitions',
+        analysis: 'analysis',
+        contentChanges: 'content_changes',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    layers: {
+        id: 'id',
+        name: 'name',
+        slug: 'slug',
+        unitType: 'unit_type',
+        description: 'description',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    metrics: {
+        id: 'id',
+        name: 'name',
+        slug: 'slug',
+        source: 'source',
+        direction: 'direction',
+        attributionWindowHours: 'attribution_window_hours',
+        cappingType: 'capping_type',
+        cappingValue: 'capping_value',
+        minSampleSize: 'min_sample_size',
+        guardrailThreshold: 'guardrail_threshold',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    events: {
+        id: 'id',
+        type: 'type',
+        experimentId: 'experiment_id',
+        phase: 'phase',
+        arm: 'arm',
+        unitId: 'unit_id',
+        unitType: 'unit_type',
+        userId: 'user_id',
+        eventName: 'event_name',
+        value: 'value',
+        ts: 'ts',
+        dimensions: 'dimensions',
+        attributes: 'attributes',
+        dedupeKey: 'dedupe_key',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    identities: {
+        id: 'id',
+        anonymousId: 'anonymous_id',
+        userId: 'user_id',
+        linkedAt: 'linked_at',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    },
+    resultsSnapshots: {
+        id: 'id',
+        experimentId: 'experiment_id',
+        phase: 'phase',
+        computedAt: 'computed_at',
+        window: 'window',
+        snapshot: 'snapshot',
+        updatedAt: 'updated_at',
+        createdAt: 'created_at'
+    }
+};
+export const ENUMS = {
+    experimentsTargetingOp: 'enum_xp_experiments_targeting_op',
+    experimentsArmsKey: 'enum_xp_experiments_arms_key',
+    experimentsArmsKind: 'enum_xp_experiments_arms_kind',
+    experimentsArmsSlot: 'enum_xp_experiments_arms_slot',
+    experimentsStatus: 'enum_xp_experiments_status',
+    experimentsKind: 'enum_xp_experiments_kind',
+    experimentsExposurePolicy: 'enum_xp_experiments_exposure_policy',
+    experimentsUnitType: 'enum_xp_experiments_unit_type',
+    experimentsAnalysisMethod: 'enum_xp_experiments_analysis_method',
+    experimentsAnalysisCuped: 'enum_xp_experiments_analysis_cuped',
+    experimentsVersionsVersionTargetingOp: 'enum__xp_experiments_v_version_targeting_op',
+    experimentsVersionsVersionArmsKey: 'enum__xp_experiments_v_version_arms_key',
+    experimentsVersionsVersionArmsKind: 'enum__xp_experiments_v_version_arms_kind',
+    experimentsVersionsVersionArmsSlot: 'enum__xp_experiments_v_version_arms_slot',
+    experimentsVersionsVersionStatus: 'enum__xp_experiments_v_version_status',
+    experimentsVersionsVersionKind: 'enum__xp_experiments_v_version_kind',
+    experimentsVersionsVersionExposurePolicy: 'enum__xp_experiments_v_version_exposure_policy',
+    experimentsVersionsVersionUnitType: 'enum__xp_experiments_v_version_unit_type',
+    experimentsVersionsVersionAnalysisMethod: 'enum__xp_experiments_v_version_analysis_method',
+    experimentsVersionsVersionAnalysisCuped: 'enum__xp_experiments_v_version_analysis_cuped',
+    phasesPhaseKind: 'enum_xp_phases_phase_kind',
+    layersUnitType: 'enum_xp_layers_unit_type',
+    metricsDirection: 'enum_xp_metrics_direction',
+    metricsCappingType: 'enum_xp_metrics_capping_type',
+    eventsType: 'enum_xp_events_type',
+    eventsUnitType: 'enum_xp_events_unit_type'
+};

package/dist/db/pgExecutor.d.ts

@@ -0,0 +1,41 @@
+import type { Pool, PoolClient } from 'pg';
+export interface Executor {
+    query<R>(text: string, params?: unknown[]): Promise<{
+        rows: R[];
+        rowCount: number;
+    }>;
+}
+/** Scan only SQL code, leaving quoted text, identifiers and nested comments alone.
+ * Both transports validate unused/missing params here before touching a database.
+ */
+export declare function scanParameters(text: string, params: unknown[]): Array<{
+    start: number;
+    end: number;
+    index: number;
+}>;
+/** Normalise top-level columns only. Finite numeric (1700) always becomes a
+ * number, accepting double precision rounding as the stats engine does. int8 (20)
+ * becomes a number only within the safe integer range; invalid/non-finite numeric
+ * and unsafe int8 values throw instead of changing a column's JS type by value.
+ * Nulls stay null. timestamp/timestamptz (1114/1184) become UTC ISO strings; infinity
+ * stays a string. JSON, text and opaque IDs stay intact. Drivers must retain raw
+ * numeric text (pg's default, and per-query overrides below) until this boundary.
+ */
+export declare function normalise<R>(value: unknown): {
+    rows: R[];
+    rowCount: number;
+};
+export declare function pgPoolExecutor(pool: Pool | PoolClient): Executor;
+/** The caller must release in finally; this connection never joins a Payload transaction. */
+export declare function ownConnection(pool: Pool): Promise<Executor & {
+    release(error?: Error): void;
+}>;
+export declare const RESULTS_TIMEOUT_MARGIN_MS = 10;
+export declare class ResultsBudgetError extends Error {
+    name: string;
+    constructor();
+}
+/** Invoke lazily so expired work never starts. Promise.race observes late source
+ * rejections too; clearing the timer keeps successful cron calls from lingering. */
+export declare function raceDeadline<T>(deadline: number, work: () => Promise<T>): Promise<T>;
+export declare function withStatementTimeout<T>(pool: Pool, ms: number, fn: (exec: Executor) => Promise<T>, deadline?: number): Promise<T>;