/**
 * Effect-based database factory.
 *
 * Creates an in-memory database with typed collections, each backed by
 * Ref<ReadonlyMap<string, T>> for O(1) ID lookup and atomic state updates.
 *
 * Query pipeline: Ref snapshot → Stream.fromIterable → filter → populate → sort → paginate → select
 * CRUD: Effect-based operations with typed error channels
 * Persistence: Optional debounced save after each CRUD mutation via Effect.forkDetach
 */
import { Effect, Schema, type Scope, Stream } from "effect";
import { type DuplicateKeyError, type ForeignKeyError, type HookError, NotFoundError, OperationError, type TransactionError, type UniqueConstraintError, ValidationError } from "../errors/crud-errors.js";
import type { MigrationError } from "../errors/migration-errors.js";
import type { PluginError } from "../errors/plugin-errors.js";
import type { DanglingReferenceError } from "../errors/query-errors.js";
import type { SourceError } from "../errors/source-errors.js";
import type { SerializationError, StorageError, UnsupportedFormatError } from "../errors/storage-errors.js";
import type { DryRunResult } from "../migrations/migration-types.js";
import type { ProseQLPlugin } from "../plugins/plugin-types.js";
import { type FormatCodec } from "../serializers/format-codec.js";
import { SerializerRegistry } from "../serializers/serializer-service.js";
import { type DocumentGraphDiagnostic, type DocumentGraphRecordProvenance } from "../storage/document-graph-source.js";
import { StorageAdapter } from "../storage/storage-service.js";
import { type AggregateConfig, type AggregateResult, type GroupedAggregateResult } from "../types/aggregate-types.js";
import type { CreateWithRelationshipsInput, DeleteWithRelationshipsOptions, DeleteWithRelationshipsResult, UpdateWithRelationshipsInput } from "../types/crud-relationship-types.js";
import type { CreateInput, CreateManyOptions, CreateManyResult, DeleteManyResult, MinimalEntity, TransactionContext, UpdateManyResult, UpdateWithOperators, UpsertInput, UpsertManyResult, UpsertResult } from "../types/crud-types.js";
import type { CursorConfig, RunnableCursorPage } from "../types/cursor-types.js";
import { type ConfiguredCollections, type DatabaseConfig } from "../types/database-config-types.js";
import type { GenerateDatabase, GenerateDatabaseWithPersistence, RelationshipDef } from "../types/types.js";
/**
 * An Effect with a lazy `runPromise` getter for non-Effect consumers.
 * Accessing `.runPromise` runs the effect and returns a Promise.
 */
export type RunnableEffect<A, E> = Effect.Effect<A, E, never> & {
    readonly runPromise: Promise<A>;
};
/**
 * A Stream with a lazy `runPromise` getter for non-Effect consumers.
 * Accessing `.runPromise` collects the stream into an array and returns a Promise.
 */
export type RunnableStream<A, E> = Stream.Stream<A, E, never> & {
    readonly runPromise: Promise<ReadonlyArray<A>>;
};
type HasId = {
    readonly id: string;
};
/**
 * Shape of a single Effect-based collection.
 * Query returns a RunnableStream (or RunnableCursorPage when cursor is specified),
 * CRUD methods return RunnableEffects.
 * Both have a `.runPromise` getter for non-Effect consumers.
 */
export interface EffectCollection<T extends HasId> {
    readonly query: (options?: {
        readonly where?: Record<string, unknown>;
        readonly populate?: Record<string, unknown>;
        readonly sort?: Record<string, "asc" | "desc">;
        readonly select?: Record<string, unknown> | ReadonlyArray<string>;
        readonly limit?: number;
        readonly offset?: number;
        readonly cursor?: CursorConfig;
    }) => RunnableStream<Record<string, unknown>, DanglingReferenceError | ValidationError> | RunnableCursorPage<Record<string, unknown>, DanglingReferenceError | ValidationError>;
    readonly findById: (id: string) => RunnableEffect<T, NotFoundError>;
    readonly exists: (id: string) => RunnableEffect<boolean, never>;
    readonly create: (input: CreateInput<T>) => RunnableEffect<T, ValidationError | DuplicateKeyError | ForeignKeyError | HookError | UniqueConstraintError>;
    readonly createMany: (inputs: ReadonlyArray<CreateInput<T>>, options?: CreateManyOptions) => RunnableEffect<CreateManyResult<T>, ValidationError | DuplicateKeyError | ForeignKeyError | HookError | UniqueConstraintError>;
    readonly update: (id: string, updates: UpdateWithOperators<T & MinimalEntity>) => RunnableEffect<T, ValidationError | NotFoundError | ForeignKeyError | HookError | UniqueConstraintError>;
    readonly updateMany: (predicate: (entity: T) => boolean, updates: UpdateWithOperators<T & MinimalEntity>) => RunnableEffect<UpdateManyResult<T>, ValidationError | ForeignKeyError | HookError | UniqueConstraintError>;
    readonly delete: (id: string, options?: {
        readonly soft?: boolean;
    }) => RunnableEffect<T, NotFoundError | OperationError | ForeignKeyError | HookError>;
    readonly deleteMany: (predicate: (entity: T) => boolean, options?: {
        readonly soft?: boolean;
        readonly limit?: number;
    }) => RunnableEffect<DeleteManyResult<T>, OperationError | ForeignKeyError | HookError>;
    readonly upsert: (input: UpsertInput<T>) => RunnableEffect<UpsertResult<T>, ValidationError | ForeignKeyError | HookError | UniqueConstraintError>;
    readonly upsertMany: (inputs: ReadonlyArray<UpsertInput<T>>) => RunnableEffect<UpsertManyResult<T>, ValidationError | ForeignKeyError | HookError | UniqueConstraintError>;
    readonly createWithRelationships: (input: CreateWithRelationshipsInput<T, Record<string, RelationshipDef>>) => RunnableEffect<T, ValidationError | ForeignKeyError | OperationError>;
    readonly updateWithRelationships: (id: string, input: UpdateWithRelationshipsInput<T, Record<string, RelationshipDef>>) => RunnableEffect<T, ValidationError | NotFoundError | ForeignKeyError | OperationError>;
    readonly deleteWithRelationships: (id: string, options?: DeleteWithRelationshipsOptions<T, Record<string, RelationshipDef>>) => RunnableEffect<DeleteWithRelationshipsResult<T>, NotFoundError | ValidationError | OperationError>;
    readonly deleteManyWithRelationships: (predicate: (entity: T) => boolean, options?: DeleteWithRelationshipsOptions<T, Record<string, RelationshipDef>> & {
        readonly limit?: number;
    }) => RunnableEffect<{
        readonly count: number;
        readonly deleted: ReadonlyArray<T>;
        readonly cascaded?: Record<string, {
            readonly count: number;
            readonly ids: ReadonlyArray<string>;
        }>;
    }, ValidationError | OperationError>;
    readonly aggregate: <C extends AggregateConfig>(config: C) => C extends {
        readonly groupBy: string | ReadonlyArray<string>;
    } ? RunnableEffect<GroupedAggregateResult, never> : RunnableEffect<AggregateResult, never>;
    /**
     * Create a reactive subscription that emits query results whenever the collection changes.
     *
     * The stream:
     * 1. Emits the current result set immediately upon subscription
     * 2. Re-emits whenever the underlying data changes (create/update/delete/reload)
     * 3. Deduplicates consecutive identical result sets to avoid spurious emissions
     *
     * The stream is scoped: it subscribes to change notifications on creation and
     * automatically unsubscribes when the scope closes or the stream is interrupted.
     *
     * @param config - Optional query configuration (where, sort, select, limit, offset, debounceMs)
     * @returns A scoped Effect that produces a Stream of result arrays
     */
    readonly watch: (config?: {
        readonly where?: Record<string, unknown>;
        readonly sort?: Record<string, "asc" | "desc">;
        readonly select?: Record<string, unknown> | ReadonlyArray<string>;
        readonly limit?: number;
        readonly offset?: number;
        readonly debounceMs?: number;
    }) => Effect.Effect<Stream.Stream<ReadonlyArray<T>>, never, Scope.Scope>;
    /**
     * Create a reactive subscription for a single entity by ID.
     *
     * Emits the entity immediately if it exists (or null if not), then re-emits
     * whenever the entity is created, updated, or deleted.
     *
     * The stream is scoped: it subscribes to change notifications on creation and
     * automatically unsubscribes when the scope closes or the stream is interrupted.
     *
     * @param id - The entity ID to watch
     * @returns A scoped Effect that produces a Stream of T | null
     */
    readonly watchById: (id: string) => Effect.Effect<Stream.Stream<T | null>, never, Scope.Scope>;
}
/**
 * Database type: a record of collection names to EffectCollections,
 * plus the $transaction method for atomic operations.
 */
export interface DocumentGraphMetadata {
    readonly getRecordProvenance: (collection: string, id: string) => Effect.Effect<DocumentGraphRecordProvenance | undefined>;
    readonly getDiagnostics: () => Effect.Effect<ReadonlyArray<DocumentGraphDiagnostic>>;
}
export type EffectDatabase<Config extends DatabaseConfig> = {
    readonly [K in keyof ConfiguredCollections<Config>]: EffectCollection<Schema.Schema.Type<ConfiguredCollections<Config>[K]["schema"]> & HasId>;
} & {
    /**
     * Execute multiple operations atomically within a transaction.
     * On success, all changes are committed and persistence is triggered.
     * On failure, all changes are rolled back and the original error is re-raised.
     */
    readonly $transaction: <A, E>(fn: (ctx: TransactionContext) => Effect.Effect<A, E>) => RunnableEffect<A, E | TransactionError>;
    readonly $documentGraph: DocumentGraphMetadata;
};
/**
 * Configuration for database persistence.
 * When provided, CRUD mutations trigger debounced saves to disk.
 */
export interface EffectDatabasePersistenceConfig {
    /** Debounce delay in milliseconds (default 100) */
    readonly writeDebounce?: number;
    /**
     * Plugin codecs to merge with the serializer registry.
     * When provided, these codecs are layered on top of the user-provided
     * SerializerRegistry service, with plugin codecs taking precedence.
     * @internal Used by plugin system integration
     */
    readonly _pluginCodecs?: ReadonlyArray<FormatCodec>;
}
/**
 * Extended database type with persistence control methods.
 */
export type EffectDatabaseWithPersistence<Config extends DatabaseConfig> = EffectDatabase<Config> & {
    /** Flush all pending debounced writes immediately. Returns a Promise. */
    readonly flush: () => Promise<void>;
    /** Returns the number of writes currently pending. */
    readonly pendingCount: () => number;
    /**
     * Preview which files need migration and what transforms would apply.
     * No transforms are executed. No files are written.
     */
    readonly $dryRunMigrations: () => RunnableEffect<DryRunResult, MigrationError | StorageError | SerializationError | UnsupportedFormatError>;
};
/**
 * Options for creating an Effect-based database.
 */
export interface EffectDatabaseOptions {
    /** Plugins to load, providing custom codecs, operators, ID generators, and global hooks */
    readonly plugins?: ReadonlyArray<ProseQLPlugin>;
}
/**
 * Create an Effect-based in-memory database.
 *
 * Accepts a DatabaseConfig and optional initial data (arrays keyed by collection name).
 * Returns an Effect that initializes Ref state for each collection and wires up
 * the query pipeline and CRUD methods.
 *
 * Optionally accepts plugins that provide custom codecs, operators, ID generators,
 * and global lifecycle hooks.
 *
 * Usage:
 * ```ts
 * const db = yield* createEffectDatabase(config, {
 *   users: [{ id: "1", name: "Alice", age: 30 }],
 *   companies: [{ id: "c1", name: "TechCorp" }],
 * })
 *
 * // Query
 * const results = yield* Stream.runCollect(db.users.query({ where: { age: { $gt: 18 } } }))
 *
 * // CRUD
 * const user = yield* db.users.create({ name: "Bob", age: 25 })
 * ```
 *
 * With plugins:
 * ```ts
 * const db = yield* createEffectDatabase(config, initialData, {
 *   plugins: [regexPlugin, snowflakeIdPlugin]
 * })
 * ```
 */
export declare const createEffectDatabase: <Config extends DatabaseConfig>(config: Config, initialData?: { readonly [K in keyof ConfiguredCollections<Config>]?: ReadonlyArray<Record<string, unknown>>; }, options?: EffectDatabaseOptions) => Effect.Effect<GenerateDatabase<Config>, MigrationError | PluginError>;
/**
 * Create an Effect-based in-memory database with persistence.
 *
 * Like `createEffectDatabase`, but additionally wires debounced persistence hooks
 * so that each CRUD mutation triggers a fire-and-forget save to disk.
 *
 * Collections with a `file` field in their config are persisted. Collections
 * without a `file` are in-memory only.
 *
 * Requires `StorageAdapter` and `SerializerRegistry` services in the environment.
 *
 * Optionally accepts plugins that provide custom codecs, operators, ID generators,
 * and global lifecycle hooks.
 *
 * Usage:
 * ```ts
 * const db = yield* createPersistentEffectDatabase(config, initialData, { writeDebounce: 200 })
 * // CRUD mutations now trigger debounced saves
 * yield* db.users.create({ name: "Alice", age: 30 })
 * // Flush all pending writes before shutdown
 * yield* db.flush()
 * ```
 *
 * With plugins:
 * ```ts
 * const db = yield* createPersistentEffectDatabase(config, initialData, persistenceConfig, {
 *   plugins: [regexPlugin, snowflakeIdPlugin]
 * })
 * ```
 */
export declare const createPersistentEffectDatabase: <Config extends DatabaseConfig>(config: Config, initialData?: { readonly [K in keyof ConfiguredCollections<Config>]?: ReadonlyArray<Record<string, unknown>>; }, persistenceConfig?: EffectDatabasePersistenceConfig, options?: EffectDatabaseOptions) => Effect.Effect<GenerateDatabaseWithPersistence<Config>, MigrationError | StorageError | SerializationError | UnsupportedFormatError | ValidationError | SourceError | PluginError, StorageAdapter | SerializerRegistry | Scope.Scope>;
export {};
//# sourceMappingURL=database-effect.d.ts.map