import sqlite3 from 'sqlite3';
import { Event, ReadEvent, ReadEventMetadataWithGlobalPosition, EmmettError, EventStore, AppendToStreamOptions, BigIntStreamPosition, AppendToStreamResultWithGlobalPosition, StreamExistsResult, ProjectionRegistration, BeforeEventStoreCommitHandler, ProjectionHandler, ProjectionDefinition, CanHandle, ProjectionInitOptions, ThenThrows, ReadEventMetadata, ReadStreamOptions, ReadStreamResult } from '@event-driven-io/emmett';

type Parameters$1 = object | string | bigint | number | boolean | null;
type SQLiteConnection = {
    close: () => void;
    command: (sql: string, values?: Parameters$1[]) => Promise<sqlite3.RunResult>;
    batchCommand: (sqls: string[]) => Promise<void>;
    query: <T>(sql: string, values?: Parameters$1[]) => Promise<T[]>;
    querySingle: <T>(sql: string, values?: Parameters$1[]) => Promise<T | null>;
    withTransaction: <T>(fn: () => Promise<T>) => Promise<T>;
};
interface SQLiteError extends Error {
    errno: number;
}
declare const isSQLiteError: (error: unknown) => error is SQLiteError;
type InMemorySharedCacheSQLiteDatabase = 'file::memory:?cache=shared';
declare const InMemorySharedCacheSQLiteDatabase = "file::memory:?cache=shared";
type InMemorySQLiteDatabase = ':memory:';
declare const InMemorySQLiteDatabase = ":memory:";
type SQLiteConnectionOptions = {
    fileName: InMemorySQLiteDatabase | string | undefined;
};
declare const sqliteConnection: (options: SQLiteConnectionOptions) => SQLiteConnection;

type SQLiteConnectionPoolOptions = {
    fileName: InMemorySQLiteDatabase | InMemorySharedCacheSQLiteDatabase | string | undefined;
    connectionOptions?: {
        singleton: true;
        connection?: SQLiteConnection;
    } | {
        singleton?: false;
        connection?: never;
    };
};
type SQLiteConnectionPool = {
    connection: () => Promise<SQLiteConnection>;
    withConnection: <Result = unknown>(handle: (connection: SQLiteConnection) => Promise<Result>) => Promise<Result>;
    close: () => Promise<void>;
};
declare const SQLiteConnectionPool: (options: SQLiteConnectionPoolOptions) => SQLiteConnectionPool;

type SQLiteEventStoreMessageBatchPullerStartFrom = {
    globalPosition: bigint;
} | 'BEGINNING' | 'END';

type SQLiteProcessorEventsBatch<EventType extends Event = Event> = {
    messages: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>[];
};
type SQLiteProcessorHandlerContext = {
    connection: SQLiteConnection;
    fileName: string;
};
type SQLiteProcessor<EventType extends Event = Event> = {
    id: string;
    start: (connection: SQLiteConnection) => Promise<SQLiteEventStoreMessageBatchPullerStartFrom | undefined>;
    isActive: boolean;
    handle: (messagesBatch: SQLiteProcessorEventsBatch<EventType>, context: {
        connection?: SQLiteConnection;
        fileName?: string;
    }) => Promise<SQLiteProcessorMessageHandlerResult>;
};
declare const SQLiteProcessor: {
    result: {
        skip: (options?: {
            reason?: string;
        }) => SQLiteProcessorMessageHandlerResult;
        stop: (options?: {
            reason?: string;
            error?: EmmettError;
        }) => SQLiteProcessorMessageHandlerResult;
    };
};
type SQLiteProcessorMessageHandlerResult = void | {
    type: 'SKIP';
    reason?: string;
} | {
    type: 'STOP';
    reason?: string;
    error?: EmmettError;
};
type SQLiteProcessorEachMessageHandler<EventType extends Event = Event> = (event: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>, context: SQLiteProcessorHandlerContext) => Promise<SQLiteProcessorMessageHandlerResult> | SQLiteProcessorMessageHandlerResult;
type SQLiteProcessorStartFrom = SQLiteEventStoreMessageBatchPullerStartFrom | 'CURRENT';
type SQLiteProcessorConnectionOptions = {
    fileName: string;
    connection?: SQLiteConnection;
};
type GenericSQLiteProcessorOptions<EventType extends Event = Event> = {
    processorId: string;
    version?: number;
    partition?: string;
    startFrom?: SQLiteProcessorStartFrom;
    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
    eachMessage: SQLiteProcessorEachMessageHandler<EventType>;
    connectionOptions?: SQLiteProcessorConnectionOptions;
};
type SQLiteProjectionProcessorOptions<EventType extends Event = Event> = {
    processorId?: string;
    version?: number;
    projection: SQLiteProjectionDefinition<EventType>;
    partition?: string;
    startFrom?: SQLiteProcessorStartFrom;
    stopAfter?: (message: ReadEvent<EventType, ReadEventMetadataWithGlobalPosition>) => boolean;
};
type SQLiteProcessorOptions<EventType extends Event = Event> = GenericSQLiteProcessorOptions<EventType> | SQLiteProjectionProcessorOptions<EventType>;

type SQLiteEventStoreConsumerConfig<ConsumerEventType extends Event = Event> = {
    processors?: SQLiteProcessor<ConsumerEventType>[];
    pulling?: {
        batchSize?: number;
        pullingFrequencyInMs?: number;
    };
};
type SQLiteEventStoreConsumer<ConsumerEventType extends Event = Event> = Readonly<{
    isRunning: boolean;
    processors: SQLiteProcessor<ConsumerEventType>[];
    processor: <EventType extends ConsumerEventType = ConsumerEventType>(options: SQLiteProcessorOptions<EventType>) => SQLiteProcessor<EventType>;
    start: () => Promise<void>;
    stop: () => Promise<void>;
    close: () => Promise<void>;
}>;

type SQLiteStreamExistsOptions = {
    partition: string;
};

type EventHandler<E extends Event = Event> = (eventEnvelope: ReadEvent<E>) => void;
declare const SQLiteEventStoreDefaultStreamVersion = 0n;
interface SQLiteEventStore extends EventStore<SQLiteReadEventMetadata> {
    appendToStream<EventType extends Event, EventPayloadType extends Event = EventType>(streamName: string, events: EventType[], options?: AppendToStreamOptions<BigIntStreamPosition, EventType, EventPayloadType>): Promise<AppendToStreamResultWithGlobalPosition>;
    consumer<ConsumerEventType extends Event = Event>(options?: SQLiteEventStoreConsumerConfig<ConsumerEventType>): SQLiteEventStoreConsumer<ConsumerEventType>;
    streamExists(streamName: string, options?: SQLiteStreamExistsOptions): Promise<StreamExistsResult>;
    schema: {
        sql(): string;
        print(): void;
        migrate(): Promise<void>;
    };
}
type SQLiteReadEventMetadata = ReadEventMetadataWithGlobalPosition;
type SQLiteReadEvent<EventType extends Event = Event> = ReadEvent<EventType, SQLiteReadEventMetadata>;
type SQLiteEventStoreConnectionOptions = {
    connection: SQLiteConnection;
};
type SQLiteEventStoreOptions = {
    projections?: ProjectionRegistration<'inline', SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>[];
    schema?: {
        autoMigration?: 'None' | 'CreateOrUpdate';
    };
    hooks?: {
        /**
         * This hook will be called **BEFORE** event store schema is created
         */
        onBeforeSchemaCreated?: (context: {
            connection: SQLiteConnection;
        }) => Promise<void> | void;
        /**
         * This hook will be called **BEFORE** events were stored in the event store.
         * @type {BeforeEventStoreCommitHandler<SQLiteEventStore, HandlerContext>}
         */
        onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
            connection: SQLiteConnection;
        }>;
        /**
         * This hook will be called **AFTER** event store schema was created
         */
        onAfterSchemaCreated?: () => Promise<void> | void;
    };
} & SQLiteConnectionPoolOptions & {
    pool?: SQLiteConnectionPool;
};
declare const getSQLiteEventStore: (options: SQLiteEventStoreOptions) => SQLiteEventStore;

type SQLiteProjectionHandlerContext = {
    connection: SQLiteConnection;
};
type SQLiteProjectionHandler<EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = ProjectionHandler<EventType, EventMetaDataType, SQLiteProjectionHandlerContext>;
type SQLiteProjectionDefinition<EventType extends Event = Event> = ProjectionDefinition<EventType, SQLiteReadEventMetadata, SQLiteProjectionHandlerContext>;
type SQLiteProjectionHandlerOptions<EventType extends Event = Event> = {
    events: ReadEvent<EventType, SQLiteReadEventMetadata>[];
    projections: SQLiteProjectionDefinition<EventType>[];
    connection: SQLiteConnection;
};
declare const handleProjections: <EventType extends Event = Event>(options: SQLiteProjectionHandlerOptions<EventType>) => Promise<void>;
declare const sqliteProjection: <EventType extends Event>(definition: SQLiteProjectionDefinition<EventType>) => SQLiteProjectionDefinition<EventType>;
type SQLiteRawBatchSQLProjection<EventType extends Event> = {
    evolve: (events: EventType[], context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[];
    canHandle: CanHandle<EventType>;
    initSQL?: string | string[];
    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void>;
};
declare const sqliteRawBatchSQLProjection: <EventType extends Event>(options: SQLiteRawBatchSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;
type SQLiteRawSQLProjection<EventType extends Event> = {
    evolve: (events: EventType, context: SQLiteProjectionHandlerContext) => Promise<string[]> | string[] | Promise<string> | string;
    canHandle: CanHandle<EventType>;
    initSQL?: string | string[];
    init?: (context: ProjectionInitOptions<SQLiteProjectionHandlerContext>) => void | Promise<void>;
};
declare const sqliteRawSQLProjection: <EventType extends Event>(options: SQLiteRawSQLProjection<EventType>) => SQLiteProjectionDefinition<EventType>;

type SQLiteProjectionSpecEvent<EventType extends Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata> = EventType & {
    metadata?: Partial<EventMetaDataType>;
};
type SQLiteProjectionSpecWhenOptions = {
    numberOfTimes: number;
};
type SQLiteProjectionAssert = (options: {
    connection: SQLiteConnection;
}) => Promise<void | boolean>;
type SQLiteProjectionSpecOptions<EventType extends Event> = {
    fileName?: string;
    connection?: SQLiteConnection;
    projection: SQLiteProjectionDefinition<EventType>;
};
type SQLiteProjectionSpec<EventType extends Event> = (givenEvents: SQLiteProjectionSpecEvent<EventType>[]) => {
    when: (events: SQLiteProjectionSpecEvent<EventType>[], options?: SQLiteProjectionSpecWhenOptions) => {
        then: (assert: SQLiteProjectionAssert, message?: string) => Promise<void>;
        thenThrows: <ErrorType extends Error = Error>(...args: Parameters<ThenThrows<ErrorType>>) => Promise<void>;
    };
};
declare const SQLiteProjectionSpec: {
    for: <EventType extends Event>(options: SQLiteProjectionSpecOptions<EventType>) => SQLiteProjectionSpec<EventType>;
};
declare const eventInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata>(streamName: string, event: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>;
declare const eventsInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata>(streamName: string, events: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[]) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[];
declare const newEventsInStream: <EventType extends Event = Event, EventMetaDataType extends SQLiteReadEventMetadata = SQLiteReadEventMetadata>(streamName: string, events: SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[]) => SQLiteProjectionSpecEvent<EventType, EventMetaDataType>[];
declare const assertSQLQueryResultMatches: <T>(sql: string, rows: T[]) => SQLiteProjectionAssert;
declare const expectSQL: {
    query: (sql: string) => {
        resultRows: {
            toBeTheSame: <T>(rows: T[]) => SQLiteProjectionAssert;
        };
    };
};

type AppendEventResult = {
    success: true;
    nextStreamPosition: bigint;
    lastGlobalPosition: bigint;
} | {
    success: false;
};
declare const appendToStream: <MessageType extends Event>(connection: SQLiteConnection, streamName: string, streamType: string, messages: MessageType[], options?: AppendToStreamOptions & {
    partition?: string;
    onBeforeCommit?: BeforeEventStoreCommitHandler<SQLiteEventStore, {
        connection: SQLiteConnection;
    }>;
}) => Promise<AppendEventResult>;

type ReadLastMessageGlobalPositionResult = {
    currentGlobalPosition: bigint | null;
};
declare const readLastMessageGlobalPosition: (db: SQLiteConnection, options?: {
    partition?: string;
}) => Promise<ReadLastMessageGlobalPositionResult>;

type ReadMessagesBatchOptions = {
    after: bigint;
    batchSize: number;
} | {
    from: bigint;
    batchSize: number;
} | {
    to: bigint;
    batchSize: number;
} | {
    from: bigint;
    to: bigint;
};
type ReadMessagesBatchResult<EventType extends Event, ReadEventMetadataType extends ReadEventMetadata = ReadEventMetadata> = {
    currentGlobalPosition: bigint;
    messages: ReadEvent<EventType, ReadEventMetadataType>[];
    areEventsLeft: boolean;
};
declare const readMessagesBatch: <MessageType extends Event, ReadEventMetadataType extends ReadEventMetadataWithGlobalPosition = ReadEventMetadataWithGlobalPosition>(db: SQLiteConnection, options: ReadMessagesBatchOptions & {
    partition?: string;
}) => Promise<ReadMessagesBatchResult<MessageType, ReadEventMetadataType>>;

type ReadProcessorCheckpointResult = {
    lastProcessedPosition: bigint | null;
};
declare const readProcessorCheckpoint: (db: SQLiteConnection, options: {
    processorId: string;
    partition?: string;
}) => Promise<ReadProcessorCheckpointResult>;

declare const readStream: <EventType extends Event, EventPayloadType extends Event = EventType>(db: SQLiteConnection, streamId: string, options?: ReadStreamOptions<BigIntStreamPosition, EventType, EventPayloadType> & {
    partition?: string;
}) => Promise<ReadStreamResult<EventType, ReadEventMetadataWithGlobalPosition>>;

type StoreLastProcessedProcessorPositionResult<Position extends bigint | null = bigint> = {
    success: true;
    newPosition: Position;
} | {
    success: false;
    reason: 'IGNORED' | 'MISMATCH';
};
declare function storeProcessorCheckpoint(db: SQLiteConnection, options: {
    processorId: string;
    version: number | undefined;
    newPosition: bigint | null;
    lastProcessedPosition: bigint | null;
    partition?: string;
}): Promise<StoreLastProcessedProcessorPositionResult<bigint | null>>;

declare const sql: (sql: string) => string;
declare const streamsTableSQL: string;
declare const messagesTableSQL: string;
declare const processorsTableSQL: string;
declare const projectionsTableSQL: string;
declare const schemaSQL: string[];
declare const createEventStoreSchema: (connection: SQLiteConnection, hooks?: SQLiteEventStoreOptions["hooks"]) => Promise<void>;

declare const emmettPrefix = "emt";
declare const globalTag = "global";
declare const defaultTag = "emt:default";
declare const unknownTag = "emt:unknown";
declare const globalNames: {
    module: string;
};
declare const streamsTable: {
    name: string;
    columns: {
        partition: {
            name: string;
        };
        isArchived: {
            name: string;
        };
    };
};
declare const messagesTable: {
    name: string;
    columns: {
        partition: {
            name: string;
        };
        isArchived: {
            name: string;
        };
    };
};
declare const processorsTable: {
    name: string;
};
declare const projectionsTable: {
    name: string;
};

declare const schema_0_41_0: string[];

declare const migration_0_42_0_SQLs: string[];
declare const migration_0_42_0_FromSubscriptionsToProcessors: (connection: SQLiteConnection) => Promise<void>;

declare const schema_0_42_0: string[];

export { type AppendEventResult, type EventHandler, InMemorySQLiteDatabase, InMemorySharedCacheSQLiteDatabase, type Parameters$1 as Parameters, type ReadLastMessageGlobalPositionResult, type ReadMessagesBatchOptions, type ReadMessagesBatchResult, type ReadProcessorCheckpointResult, type SQLiteConnection, SQLiteConnectionPool, type SQLiteConnectionPoolOptions, type SQLiteError, type SQLiteEventStore, type SQLiteEventStoreConnectionOptions, SQLiteEventStoreDefaultStreamVersion, type SQLiteEventStoreOptions, type SQLiteProjectionAssert, type SQLiteProjectionDefinition, type SQLiteProjectionHandler, type SQLiteProjectionHandlerContext, type SQLiteProjectionHandlerOptions, SQLiteProjectionSpec, type SQLiteProjectionSpecEvent, type SQLiteProjectionSpecOptions, type SQLiteProjectionSpecWhenOptions, type SQLiteRawBatchSQLProjection, type SQLiteRawSQLProjection, type SQLiteReadEvent, type SQLiteReadEventMetadata, type StoreLastProcessedProcessorPositionResult, appendToStream, assertSQLQueryResultMatches, createEventStoreSchema, defaultTag, emmettPrefix, eventInStream, eventsInStream, expectSQL, getSQLiteEventStore, globalNames, globalTag, handleProjections, isSQLiteError, messagesTable, messagesTableSQL, migration_0_42_0_FromSubscriptionsToProcessors, migration_0_42_0_SQLs, newEventsInStream, processorsTable, processorsTableSQL, projectionsTable, projectionsTableSQL, readLastMessageGlobalPosition, readMessagesBatch, readProcessorCheckpoint, readStream, schemaSQL, schema_0_41_0, schema_0_42_0, sql, sqliteConnection, sqliteProjection, sqliteRawBatchSQLProjection, sqliteRawSQLProjection, storeProcessorCheckpoint, streamsTable, streamsTableSQL, unknownTag };