import { F as FilterGroup, A as AnySchema, m as OrmAdapterLike, n as Repo, S as Schema, o as SchemaField, j as DiscoveredSchema, O as OrmAdapter, p as ChangeFor, q as AnyChange, r as AnyMigration, s as Migration } from '../adapter-Coap9ISX.js';
export { c as AddFieldChange, h as AddForeignKeyChange, f as AddIndexChange, am as AggregateBuilder, v as AggregateOpName, b as AggregateSpec, an as AllBuilder, ao as AllBuilderSurface, a3 as AnyComputedField, $ as AnyField, k as AnyFieldSpec, aj as AnyPreloadDef, ag as AnyRelDef, a1 as AnySchemaField, a as AnyUpdateOp, X as ApplyMethodKey, aQ as ArrayFieldOf, W as Change, Z as ChangeKindFor, aO as ComparableFieldOf, a2 as ComputedField, C as CreateTableChange, L as DiscoveredField, P as DiscoveredForeignKey, N as DiscoveredIndex, d as DropFieldChange, i as DropForeignKeyChange, g as DropIndexChange, D as DropTableChange, V as ExecuteChange, _ as Field, T as FieldSpec, t as FieldTypeName, a4 as Filter, a5 as FilterChild, a6 as FilterFactory, a7 as FilterGroupOp, u as FilterOpName, l as ForeignKeyAction, a9 as GatedFilterFactory, a8 as GatedFilterGroup, b1 as HasOp, aU as IncOp, w as InferAdapterConfig, x as InferAdapterQueryableOps, y as InferRawArgs, z as InferRawReturn, ad as IterationOptions, I as IterationQueryOptions, Y as KindFromMethod, ae as ManyRelation, aX as MaxOp, aW as MinOp, M as ModifyFieldChange, aV as MulOp, ai as NestedPreloadDef, aN as NumericFieldOf, aR as ObjectFieldOf, ap as OneBuilder, aq as OneBuilderSurface, af as OneRelation, aP as OptionalFieldOf, ac as OrderBy, G as OrmAdapterConfig, E as OrmUse, K as OrmValidationError, H as OrmValidationErrorKind, J as OrmValidationFailure, ar as Paginated, a$ as PatchOp, ak as PreloadedMap, a_ as PullOp, aZ as PushOp, Q as QueryOptions, al as Relations, e as RenameFieldChange, R as RenameTableChange, av as RepoSurface, ah as ResolveRelDef, aC as SchemaBuilder, B as SchemaCompatible, aw as SchemaComputedDefs, ay as SchemaComputedOutput, as as SchemaContext, aD as SchemaCreateInput, aA as SchemaFields, az as SchemaOutput, ax as SchemaPersistedOutput, at as SchemaRef, au as SchemaRefSurface, aB as SchemaTaggedFields, aE as SchemaUpdateInput, aF as SchemaUpdateOutput, aT as SetOp, aS as SetValues, aY as UnsetOp, b2 as UpdateOp, U as UpdateOpName, aa as assertNormalisedAggregate, ab as assertNormalisedFilter, aL as composeSchemaConfig, bd as flattenOps, b4 as inc, b0 as isUpdateOp, b7 as max, b6 as min, b5 as mul, bc as opTouchedFields, bb as patch, ba as pull, b9 as push, b3 as set, a0 as toFieldName, aG as tryValidateCreateRow, b8 as unset, aH as validateCreate, aI as validateCreateMany, aJ as validateUpdate, aK as validateUpdateOps, aM as validateUpsertConflicts } from '../adapter-Coap9ISX.js';
import { E as EquippedError } from '../equippedError-Cmo60Kn-.js';
import * as valleyed from 'valleyed';
import { Pipe, PipeOutput, PipeInput } from 'valleyed';

declare class OrmIntrospectionError extends EquippedError {
    readonly adapter: string;
    readonly table: string;
    constructor(opts: {
        adapter: string;
        table: string;
        cause: unknown;
    });
}

type OrmMigrationPhase = 'lock' | 'load' | 'session' | 'user' | 'record';
declare class OrmMigrationError extends EquippedError {
    readonly id: string;
    readonly phase: OrmMigrationPhase;
    constructor(opts: {
        id: string;
        phase: OrmMigrationPhase;
        cause: unknown;
    });
}

type OrmNotFoundOperation = 'findOne' | 'updateOne' | 'deleteOne';
declare class OrmNotFoundError extends EquippedError {
    readonly schema: string;
    readonly operation: OrmNotFoundOperation;
    readonly where: FilterGroup;
    constructor(opts: {
        schema: string;
        operation: OrmNotFoundOperation;
        where: FilterGroup;
        message?: string;
    });
}

declare class OrmReplayError extends EquippedError {
    readonly key: string;
    readonly eventName: string;
    constructor(opts: {
        key: string;
        name: string;
        cause: unknown;
    });
}

type ConfigTransform<C> = (config: C, schema: AnySchema) => C;

type EventContext = {
    key: string;
    name: string;
    ts: number;
    body: unknown;
    by: string | null;
    at: Date;
    firstRun: boolean;
};
type HandlerDef<P extends Pipe<any, any> = Pipe<any, any>, R = unknown> = {
    pipe: P;
    handle: (payload: PipeOutput<P>, ctx: EventContext) => R | Promise<R>;
};
type FireFn<P extends Pipe<any, any>, R> = (payload: PipeInput<P>, ctx?: {
    by?: string;
    at?: Date;
}) => Promise<R>;
declare class HandlerRegistry {
    #private;
    register(name: string, def: HandlerDef): void;
    get(name: string): HandlerDef;
    list(): string[];
}

declare class EventLog<A extends OrmAdapterLike<any>> {
    #private;
    constructor(repo: Repo<A>, registry: HandlerRegistry);
    handler<P extends Pipe<any, any>, R>(name: string, def: HandlerDef<P, R>): FireFn<P, R>;
    replay(opts?: {
        from?: Date;
    }): Promise<void>;
    rerun(key: string): Promise<void>;
    static from<A extends OrmAdapterLike<any>>(repo: Repo<A>): {
        build: () => EventLog<A>;
    };
}

declare const EventLogSchema: Schema<"event_log", SchemaField<"key", valleyed.Pipe<string, string>, true>, {
    name: SchemaField<"name", valleyed.Pipe<string, string>, false>;
    body: SchemaField<"body", valleyed.Pipe<unknown, unknown>, false>;
    ts: SchemaField<"ts", valleyed.Pipe<number, number>, false>;
    by: SchemaField<"by", valleyed.Pipe<string | null, string | null>, false>;
}, {}>;

type IntrospectableAdapter<A> = A extends {
    introspect(): Promise<DiscoveredSchema[]>;
} ? A : never;
declare class MigrationCodegen<A extends OrmAdapterLike<any>> {
    #private;
    constructor(_repo: Repo<A>, adapter: OrmAdapter & {
        introspect(): Promise<DiscoveredSchema[]>;
    }, target: ReadonlyArray<AnySchema>);
    diff(): Promise<ReadonlyArray<ChangeFor<A>> | null>;
    discover(): Promise<ReadonlyArray<DiscoveredSchema>>;
    static from<A extends OrmAdapterLike<any>>(repo: Repo<IntrospectableAdapter<A>>, adapter: A & OrmAdapter & {
        introspect(): Promise<DiscoveredSchema[]>;
    }): {
        target(schemas: ReadonlyArray<AnySchema>): {
            build(): MigrationCodegen<A>;
        };
    };
}

declare function diffSchemas(adapter: OrmAdapter, target: ReadonlyArray<AnySchema>, current: ReadonlyArray<DiscoveredSchema>): ReadonlyArray<AnyChange>;

type PendingOpts = {
    to?: string;
    steps?: number;
};
declare function computePending(declared: ReadonlyArray<AnyMigration>, applied: ReadonlyArray<{
    id: string;
    appliedAt: number;
}>, opts?: PendingOpts): {
    pending: AnyMigration[];
    skipped: string[];
};

type RunResult = {
    ran: string[];
    skipped: string[];
};
type StatusEntry = {
    id: string;
    applied: boolean;
    appliedAt?: number;
};
type HasAcquireMigrationLock<A> = 'acquireMigrationLock' extends keyof A ? A['acquireMigrationLock'] extends (...args: any) => any ? true : false : false;
type WithoutLockStep<A extends OrmAdapterLike<any>> = HasAcquireMigrationLock<A> extends true ? {} : {
    withoutLock(): {
        build(): Migrator<A>;
    };
};
declare class Migrator<A extends OrmAdapterLike<any>> {
    #private;
    constructor(repo: Repo<A>, adapter: OrmAdapter, migrations: ReadonlyArray<Migration<A>>, withoutLock?: boolean);
    up(opts?: PendingOpts): Promise<RunResult>;
    status(): Promise<StatusEntry[]>;
    dry(opts?: PendingOpts): Promise<{
        would: string[];
    }>;
    static from<A extends OrmAdapterLike<any>>(repo: Repo<A>, adapter: A & OrmAdapter): {
        migrations(migrations: ReadonlyArray<Migration<A>>): {
            build(): Migrator<A>;
        } & WithoutLockStep<A>;
    };
}

export { AnyChange, AnyMigration, AnySchema, ChangeFor, type ConfigTransform, DiscoveredSchema, type EventContext, EventLog, EventLogSchema, FilterGroup, type FireFn, type HandlerDef, type IntrospectableAdapter, Migration, MigrationCodegen, Migrator, OrmAdapter, OrmAdapterLike, OrmIntrospectionError, OrmMigrationError, type OrmMigrationPhase, OrmNotFoundError, type OrmNotFoundOperation, OrmReplayError, type PendingOpts, Repo, Schema, SchemaField, type StatusEntry, computePending, diffSchemas };