opfsql 0.0.2

package/dist/parser/types.d.ts

@@ -0,0 +1,482 @@
+export declare enum TokenType {
+    INTEGER_LITERAL = 0,
+    FLOAT_LITERAL = 1,
+    STRING_LITERAL = 2,
+    BLOB_LITERAL = 3,
+    PARAMETER = 4,
+    IDENTIFIER = 5,
+    QUOTED_IDENTIFIER = 6,
+    EQUALS = 7,
+    NOT_EQUALS = 8,
+    LESS_THAN = 9,
+    LESS_THAN_EQUAL = 10,
+    GREATER_THAN = 11,
+    GREATER_THAN_EQUAL = 12,
+    PLUS = 13,
+    MINUS = 14,
+    STAR = 15,
+    SLASH = 16,
+    PERCENT = 17,
+    PIPE_PIPE = 18,
+    LEFT_PAREN = 19,
+    RIGHT_PAREN = 20,
+    LEFT_BRACKET = 21,
+    RIGHT_BRACKET = 22,
+    COMMA = 23,
+    SEMICOLON = 24,
+    DOT = 25,
+    SELECT = 26,
+    FROM = 27,
+    WHERE = 28,
+    JOIN = 29,
+    LEFT = 30,
+    RIGHT = 31,
+    INNER = 32,
+    OUTER = 33,
+    CROSS = 34,
+    ON = 35,
+    USING = 36,
+    AS = 37,
+    DISTINCT = 38,
+    ALL = 39,
+    GROUP = 40,
+    BY = 41,
+    HAVING = 42,
+    ORDER = 43,
+    ASC = 44,
+    DESC = 45,
+    NULLS = 46,
+    FIRST = 47,
+    LAST = 48,
+    LIMIT = 49,
+    OFFSET = 50,
+    UNION = 51,
+    INSERT = 52,
+    INTO = 53,
+    VALUES = 54,
+    UPDATE = 55,
+    SET = 56,
+    DELETE = 57,
+    CREATE = 58,
+    TABLE = 59,
+    INDEX = 60,
+    UNIQUE = 61,
+    IF = 62,
+    NOT = 63,
+    EXISTS = 64,
+    ALTER = 65,
+    ADD = 66,
+    DROP = 67,
+    COLUMN = 68,
+    BEGIN = 69,
+    COMMIT = 70,
+    ROLLBACK = 71,
+    TRANSACTION = 72,
+    WITH = 73,
+    AND = 74,
+    OR = 75,
+    IN = 76,
+    BETWEEN = 77,
+    LIKE = 78,
+    IS = 79,
+    NULL_KW = 80,
+    PRIMARY = 81,
+    KEY = 82,
+    FOREIGN = 83,
+    REFERENCES = 84,
+    DEFAULT = 85,
+    CASE = 86,
+    WHEN = 87,
+    THEN = 88,
+    ELSE = 89,
+    END = 90,
+    CAST = 91,
+    TRUE_KW = 92,
+    FALSE_KW = 93,
+    CONFLICT = 94,
+    DO = 95,
+    NOTHING = 96,
+    EXCLUDED = 97,
+    AUTOINCREMENT = 98,
+    EXPLAIN = 99,
+    INTEGER_KW = 100,
+    INT_KW = 101,
+    BIGINT_KW = 102,
+    SMALLINT_KW = 103,
+    REAL_KW = 104,
+    FLOAT_KW = 105,
+    DOUBLE_KW = 106,
+    TEXT_KW = 107,
+    VARCHAR_KW = 108,
+    CHAR_KW = 109,
+    BLOB_KW = 110,
+    BOOLEAN_KW = 111,
+    BOOL_KW = 112,
+    JSON_KW = 113,
+    EOF = 114
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+export declare enum LogicalTypeId {
+    INTEGER = "INTEGER",
+    BIGINT = "BIGINT",
+    SMALLINT = "SMALLINT",
+    FLOAT = "FLOAT",
+    DOUBLE = "DOUBLE",
+    VARCHAR = "VARCHAR",
+    BLOB = "BLOB",
+    BOOLEAN = "BOOLEAN",
+    JSON = "JSON"
+}
+export interface LogicalType {
+    id: LogicalTypeId;
+}
+export interface Value {
+    type: LogicalType;
+    is_null: boolean;
+    value: string | number | boolean | Uint8Array | Record<string, unknown> | unknown[] | null;
+}
+import type { JsonPathSegment } from '../types.js';
+export type { JsonPathSegment };
+export declare enum ExpressionClass {
+    COLUMN_REF = "COLUMN_REF",
+    CONSTANT = "CONSTANT",
+    PARAMETER = "PARAMETER",
+    COMPARISON = "COMPARISON",
+    CONJUNCTION = "CONJUNCTION",
+    OPERATOR = "OPERATOR",
+    BETWEEN = "BETWEEN",
+    FUNCTION = "FUNCTION",
+    SUBQUERY = "SUBQUERY",
+    CASE = "CASE",
+    CAST = "CAST",
+    STAR = "STAR"
+}
+export declare enum ExpressionType {
+    COMPARE_EQUAL = "COMPARE_EQUAL",
+    COMPARE_NOTEQUAL = "COMPARE_NOTEQUAL",
+    COMPARE_LESSTHAN = "COMPARE_LESSTHAN",
+    COMPARE_LESSTHANOREQUALTO = "COMPARE_LESSTHANOREQUALTO",
+    COMPARE_GREATERTHAN = "COMPARE_GREATERTHAN",
+    COMPARE_GREATERTHANOREQUALTO = "COMPARE_GREATERTHANOREQUALTO",
+    CONJUNCTION_AND = "CONJUNCTION_AND",
+    CONJUNCTION_OR = "CONJUNCTION_OR",
+    OPERATOR_NOT = "OPERATOR_NOT",
+    OPERATOR_IS_NULL = "OPERATOR_IS_NULL",
+    OPERATOR_IS_NOT_NULL = "OPERATOR_IS_NOT_NULL",
+    OPERATOR_IN = "OPERATOR_IN",
+    OPERATOR_NOT_IN = "OPERATOR_NOT_IN",
+    COMPARE_LIKE = "COMPARE_LIKE",
+    COMPARE_NOT_LIKE = "COMPARE_NOT_LIKE",
+    OPERATOR_ADD = "OPERATOR_ADD",
+    OPERATOR_SUBTRACT = "OPERATOR_SUBTRACT",
+    OPERATOR_MULTIPLY = "OPERATOR_MULTIPLY",
+    OPERATOR_DIVIDE = "OPERATOR_DIVIDE",
+    OPERATOR_MOD = "OPERATOR_MOD",
+    OPERATOR_NEGATE = "OPERATOR_NEGATE",
+    OPERATOR_CONCAT = "OPERATOR_CONCAT"
+}
+export interface ColumnRefExpression {
+    expression_class: ExpressionClass.COLUMN_REF;
+    alias: string | null;
+    column_names: string[];
+    path?: JsonPathSegment[];
+}
+export interface ConstantExpression {
+    expression_class: ExpressionClass.CONSTANT;
+    alias: string | null;
+    value: Value;
+}
+/** $1-based parameter placeholder. index is 0-based internally. */
+export interface ParameterExpression {
+    expression_class: ExpressionClass.PARAMETER;
+    alias: string | null;
+    index: number;
+}
+export interface ComparisonExpression {
+    expression_class: ExpressionClass.COMPARISON;
+    alias: string | null;
+    type: ExpressionType;
+    left: ParsedExpression;
+    right: ParsedExpression;
+}
+export interface ConjunctionExpression {
+    expression_class: ExpressionClass.CONJUNCTION;
+    alias: string | null;
+    type: ExpressionType;
+    children: ParsedExpression[];
+}
+export interface OperatorExpression {
+    expression_class: ExpressionClass.OPERATOR;
+    alias: string | null;
+    type: ExpressionType;
+    children: ParsedExpression[];
+}
+export interface BetweenExpression {
+    expression_class: ExpressionClass.BETWEEN;
+    alias: string | null;
+    input: ParsedExpression;
+    lower: ParsedExpression;
+    upper: ParsedExpression;
+}
+export interface FunctionExpression {
+    expression_class: ExpressionClass.FUNCTION;
+    alias: string | null;
+    function_name: string;
+    children: ParsedExpression[];
+    distinct: boolean;
+    is_star: boolean;
+}
+export interface SubqueryExpression {
+    expression_class: ExpressionClass.SUBQUERY;
+    alias: string | null;
+    subquery_type: 'SCALAR' | 'EXISTS' | 'NOT_EXISTS' | 'ANY' | 'ALL';
+    subquery: SelectStatement;
+    child: ParsedExpression | null;
+    comparison_type?: ExpressionType;
+}
+export interface CaseExpression {
+    expression_class: ExpressionClass.CASE;
+    alias: string | null;
+    case_checks: Array<{
+        when_expr: ParsedExpression;
+        then_expr: ParsedExpression;
+    }>;
+    else_expr: ParsedExpression | null;
+}
+export interface CastExpression {
+    expression_class: ExpressionClass.CAST;
+    alias: string | null;
+    child: ParsedExpression;
+    cast_type: LogicalType;
+}
+export interface StarExpression {
+    expression_class: ExpressionClass.STAR;
+    alias: string | null;
+    table_name: string | null;
+}
+export type ParsedExpression = ColumnRefExpression | ConstantExpression | ParameterExpression | ComparisonExpression | ConjunctionExpression | OperatorExpression | BetweenExpression | FunctionExpression | SubqueryExpression | CaseExpression | CastExpression | StarExpression;
+export declare enum TableRefType {
+    BASE_TABLE = "BASE_TABLE",
+    JOIN = "JOIN",
+    SUBQUERY = "SUBQUERY"
+}
+export declare enum JoinType {
+    INNER = "INNER",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    CROSS = "CROSS"
+}
+export interface BaseTableRef {
+    type: TableRefType.BASE_TABLE;
+    table_name: string;
+    alias: string | null;
+    schema_name: string | null;
+}
+export interface JoinRef {
+    type: TableRefType.JOIN;
+    left: TableRef;
+    right: TableRef;
+    condition: ParsedExpression | null;
+    join_type: JoinType;
+    using_columns: string[];
+}
+export interface SubqueryRef {
+    type: TableRefType.SUBQUERY;
+    subquery: SelectStatement;
+    alias: string | null;
+    column_name_alias: string[];
+}
+export type TableRef = BaseTableRef | JoinRef | SubqueryRef;
+export declare enum ResultModifierType {
+    ORDER_MODIFIER = "ORDER_MODIFIER",
+    LIMIT_MODIFIER = "LIMIT_MODIFIER",
+    DISTINCT_MODIFIER = "DISTINCT_MODIFIER"
+}
+export declare enum OrderType {
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export declare enum OrderByNullType {
+    NULLS_FIRST = "NULLS_FIRST",
+    NULLS_LAST = "NULLS_LAST"
+}
+export interface OrderByNode {
+    type: OrderType;
+    null_order: OrderByNullType;
+    expression: ParsedExpression;
+}
+export interface OrderModifier {
+    type: ResultModifierType.ORDER_MODIFIER;
+    orders: OrderByNode[];
+}
+export interface LimitModifier {
+    type: ResultModifierType.LIMIT_MODIFIER;
+    limit: ParsedExpression | null;
+    offset: ParsedExpression | null;
+}
+export interface DistinctModifier {
+    type: ResultModifierType.DISTINCT_MODIFIER;
+    distinct_on_targets: ParsedExpression[];
+}
+export type ResultModifier = OrderModifier | LimitModifier | DistinctModifier;
+export interface GroupByNode {
+    group_expressions: ParsedExpression[];
+}
+export interface CTENode {
+    query: SelectStatement;
+    aliases: string[];
+}
+export interface CTEMap {
+    map: Record<string, CTENode>;
+    recursive: boolean;
+}
+export interface SelectNode {
+    type: 'SELECT_NODE';
+    select_list: ParsedExpression[];
+    from_table: TableRef | null;
+    where_clause: ParsedExpression | null;
+    groups: GroupByNode;
+    having: ParsedExpression | null;
+    modifiers: ResultModifier[];
+    cte_map: CTEMap;
+}
+export declare enum StatementType {
+    SELECT_STATEMENT = "SELECT_STATEMENT",
+    INSERT_STATEMENT = "INSERT_STATEMENT",
+    UPDATE_STATEMENT = "UPDATE_STATEMENT",
+    DELETE_STATEMENT = "DELETE_STATEMENT",
+    CREATE_TABLE_STATEMENT = "CREATE_TABLE_STATEMENT",
+    CREATE_INDEX_STATEMENT = "CREATE_INDEX_STATEMENT",
+    ALTER_TABLE_STATEMENT = "ALTER_TABLE_STATEMENT",
+    DROP_STATEMENT = "DROP_STATEMENT",
+    TRANSACTION_STATEMENT = "TRANSACTION_STATEMENT",
+    EXPLAIN_STATEMENT = "EXPLAIN_STATEMENT"
+}
+export interface SelectStatement {
+    type: StatementType.SELECT_STATEMENT;
+    node: SelectNode | SetOperationNode;
+}
+export declare enum SetOperationType {
+    UNION = "UNION",
+    UNION_ALL = "UNION_ALL"
+}
+export interface SetOperationNode {
+    type: 'SET_OPERATION_NODE';
+    set_op_type: SetOperationType;
+    left: SelectNode | SetOperationNode;
+    right: SelectNode;
+    modifiers: ResultModifier[];
+    cte_map: CTEMap;
+}
+export interface SetOperationStatement {
+    type: StatementType.SELECT_STATEMENT;
+    node: SetOperationNode;
+}
+export interface ColumnDefinition {
+    name: string;
+    type: LogicalType;
+    is_primary_key: boolean;
+    is_not_null: boolean;
+    is_unique: boolean;
+    is_autoincrement: boolean;
+    default_value: ParsedExpression | null;
+}
+export interface ForeignKeyConstraint {
+    columns: string[];
+    ref_table: string;
+    ref_columns: string[];
+}
+export interface OnConflictUpdate {
+    type: 'UPDATE';
+    setClauses: UpdateSetClause[];
+    whereClause: ParsedExpression | null;
+}
+export interface OnConflictClause {
+    conflictTarget: string[] | null;
+    action: 'NOTHING' | OnConflictUpdate;
+}
+export interface InsertStatement {
+    type: StatementType.INSERT_STATEMENT;
+    table: string;
+    columns: string[];
+    values: ParsedExpression[][];
+    select_statement: SelectStatement | null;
+    onConflict: OnConflictClause | null;
+}
+export interface UpdateSetClause {
+    column: string;
+    value: ParsedExpression;
+}
+export interface UpdateStatement {
+    type: StatementType.UPDATE_STATEMENT;
+    table: string;
+    set_clauses: UpdateSetClause[];
+    where_clause: ParsedExpression | null;
+}
+export interface DeleteStatement {
+    type: StatementType.DELETE_STATEMENT;
+    table: string;
+    where_clause: ParsedExpression | null;
+}
+export interface CreateTableStatement {
+    type: StatementType.CREATE_TABLE_STATEMENT;
+    table: string;
+    if_not_exists: boolean;
+    columns: ColumnDefinition[];
+    primary_key: string[];
+    foreign_keys: ForeignKeyConstraint[];
+}
+export interface CreateIndexStatement {
+    type: StatementType.CREATE_INDEX_STATEMENT;
+    index_name: string;
+    table_name: string;
+    expressions: ParsedExpression[];
+    is_unique: boolean;
+    if_not_exists: boolean;
+}
+export declare enum AlterType {
+    ADD_COLUMN = "ADD_COLUMN",
+    DROP_COLUMN = "DROP_COLUMN"
+}
+export interface AlterTableStatement {
+    type: StatementType.ALTER_TABLE_STATEMENT;
+    table: string;
+    alter_type: AlterType;
+    column_def: ColumnDefinition | null;
+    column_name: string | null;
+}
+export declare enum DropType {
+    TABLE = "TABLE",
+    INDEX = "INDEX"
+}
+export interface DropStatement {
+    type: StatementType.DROP_STATEMENT;
+    drop_type: DropType;
+    name: string;
+    if_exists: boolean;
+}
+export declare enum TransactionType {
+    BEGIN = "BEGIN",
+    COMMIT = "COMMIT",
+    ROLLBACK = "ROLLBACK"
+}
+export interface TransactionStatement {
+    type: StatementType.TRANSACTION_STATEMENT;
+    transaction_type: TransactionType;
+}
+export interface ExplainStatement {
+    type: StatementType.EXPLAIN_STATEMENT;
+    statement: Statement;
+}
+export type Statement = SelectStatement | SetOperationStatement | InsertStatement | UpdateStatement | DeleteStatement | CreateTableStatement | CreateIndexStatement | AlterTableStatement | DropStatement | TransactionStatement | ExplainStatement;
+export declare class ParseError extends Error {
+    line: number;
+    column: number;
+    token: Token;
+    constructor(message: string, line: number, column: number, token: Token);
+}

package/dist/store/backend/memory-storage.d.ts

@@ -0,0 +1,16 @@
+import type { SyncIPageStorage } from "../types.js";
+/**
+ * Test-only in-memory SyncIPageStorage. Uses structuredClone to mimic real storage
+ * (no shared references between stored and returned values).
+ */
+export declare class MemoryPageStorage implements SyncIPageStorage {
+    private pages;
+    private nextPageId;
+    open(): Promise<void>;
+    close(): void;
+    readPage<T>(pageNo: number): T | null;
+    writePage(pageNo: number, value: unknown): void;
+    getNextPageId(): number;
+    writeHeader(nextPageId: number): void;
+    flush(): void;
+}

package/dist/store/backend/node-storage.d.ts

@@ -0,0 +1,33 @@
+import type { ISyncFileHandle } from "../wal/file-handle.js";
+import type { SyncIPageStorage } from "../types.js";
+export declare class NodeFileHandle implements ISyncFileHandle {
+    private fd;
+    constructor(filePath: string);
+    read(buffer: Uint8Array, options?: {
+        at?: number;
+    }): number;
+    write(buffer: Uint8Array, options?: {
+        at?: number;
+    }): number;
+    getSize(): number;
+    truncate(size: number): void;
+    flush(): void;
+    close(): void;
+}
+export declare class NodeSyncStorage implements SyncIPageStorage {
+    private readonly filePath;
+    private handle;
+    private pageSize;
+    private nextPageId;
+    constructor(filePath: string);
+    open(): Promise<void>;
+    close(): void;
+    readPage<T>(pageNo: number): T | null;
+    writePage(pageNo: number, value: unknown): void;
+    getNextPageId(): number;
+    writeHeader(nextPageId: number): void;
+    truncateToSize(): void;
+    flush(): void;
+    private initNewFile;
+    private readHeader;
+}

package/dist/store/backend/opfs-storage.d.ts

@@ -0,0 +1,39 @@
+import type { SyncIPageStorage } from "../types.js";
+interface FileSystemSyncAccessHandle {
+    getSize(): number;
+    read(buffer: Uint8Array, options?: {
+        at?: number;
+    }): number;
+    write(buffer: Uint8Array, options?: {
+        at?: number;
+    }): number;
+    truncate(size: number): void;
+    flush(): void;
+    close(): void;
+}
+declare global {
+    interface FileSystemFileHandle {
+        createSyncAccessHandle(options?: {
+            mode?: "readwrite" | "read-only" | "readwrite-unsafe";
+        }): Promise<FileSystemSyncAccessHandle>;
+    }
+}
+export declare class OPFSSyncStorage implements SyncIPageStorage {
+    private readonly dbName;
+    private handle;
+    private pageSize;
+    private nextPageId;
+    constructor(dbName: string);
+    open(): Promise<void>;
+    close(): void;
+    readPage<T>(pageNo: number): T | null;
+    writePage(pageNo: number, value: unknown): void;
+    getNextPageId(): number;
+    writeHeader(nextPageId: number): void;
+    /** Shrink file to match nextPageId. Safe only after flush(). */
+    truncateToSize(): void;
+    flush(): void;
+    private initNewFile;
+    private readHeader;
+}
+export {};

package/dist/store/btree/btree.d.ts

@@ -0,0 +1,48 @@
+import type { IPageManager, RowId } from '../types.js';
+import type { IndexKey } from './types.js';
+import { type SearchPredicate } from './search-bounds.js';
+export type { SearchPredicate } from './search-bounds.js';
+export declare class BTree {
+    private readonly indexName;
+    private readonly pm;
+    private readonly unique;
+    constructor(indexName: string, pm: IPageManager, unique: boolean);
+    insert(key: IndexKey, rowId: RowId): Promise<void>;
+    delete(key: IndexKey, rowId: RowId): Promise<void>;
+    search(predicates: SearchPredicate[], totalColumns?: number): Promise<RowId[]>;
+    bulkLoad(entries: Array<{
+        key: IndexKey;
+        rowId: RowId;
+    }>): Promise<void>;
+    drop(): Promise<void>;
+    private insertIntoLeaf;
+    private removeFromLeaf;
+    private rangeScan;
+    private pointLookup;
+    private findLeftmostLeaf;
+    private collectRange;
+    private isBelowLower;
+    private isAboveUpper;
+    private mergeEntries;
+    private buildLeaves;
+    private linkAndWriteLeaves;
+    private buildInternalLevels;
+    private splitLeaf;
+    private propagateSplit;
+    private splitInternal;
+    private createNewRoot;
+    private findLeafPath;
+    /** Find insertion point: first position where keys[pos] >= key. */
+    private bisectLeft;
+    /** Find child index: first position where key < keys[pos]. */
+    private bisectRight;
+    private metaKey;
+    private nodeKey;
+    private readMeta;
+    private writeMeta;
+    private readNode;
+    private writeNode;
+    private allocNodeId;
+    private createLeaf;
+    private initEmptyTree;
+}

package/dist/store/btree/compare.d.ts

@@ -0,0 +1,13 @@
+import type { IndexKey } from './types.js';
+/**
+ * Compare two composite index keys lexicographically.
+ * NULL sorts LAST (greater than all non-null values).
+ * Two NULLs in the same position are considered equal.
+ */
+export declare function compareIndexKeys(a: IndexKey, b: IndexKey): number;
+/**
+ * Check if a key contains any NULL components.
+ * Used for UNIQUE constraint: rows with NULL in any indexed column
+ * are exempt from uniqueness checks (SQL standard).
+ */
+export declare function keyHasNull(key: IndexKey): boolean;

package/dist/store/btree/search-bounds.d.ts

@@ -0,0 +1,15 @@
+import type { IndexKey } from './types.js';
+export interface SearchPredicate {
+    columnPosition: number;
+    comparisonType: 'EQUAL' | 'LESS' | 'GREATER' | 'LESS_EQUAL' | 'GREATER_EQUAL';
+    value: string | number | boolean | null;
+}
+export interface ScanBounds {
+    lowerKey: IndexKey | null;
+    lowerInclusive: boolean;
+    upperKey: IndexKey | null;
+    upperInclusive: boolean;
+    exactKey: IndexKey | null;
+    prefixScan?: boolean;
+}
+export declare function computeBounds(predicates: SearchPredicate[], totalColumns?: number): ScanBounds;

package/dist/store/btree/types.d.ts

@@ -0,0 +1,33 @@
+import type { RowId } from '../types.js';
+export type IndexKeyValue = string | number | boolean | null;
+/** Composite key: one element per indexed column. */
+export type IndexKey = IndexKeyValue[];
+export interface BTreeLeafNode {
+    kind: 'leaf';
+    nodeId: number;
+    keys: IndexKey[];
+    /** rowIds[i] = array of RowId for keys[i]. Non-unique indexes may have multiple. */
+    rowIds: RowId[][];
+    /** Pointer to the next leaf for efficient range scans. */
+    nextLeafId: number | null;
+}
+export interface BTreeInternalNode {
+    kind: 'internal';
+    nodeId: number;
+    /** Separator keys. keys.length === children.length - 1. */
+    keys: IndexKey[];
+    /** Child node IDs. */
+    children: number[];
+}
+export type BTreeNode = BTreeLeafNode | BTreeInternalNode;
+export interface BTreeMeta {
+    rootNodeId: number;
+    /** Tree height. 1 means root is a leaf. */
+    height: number;
+    /** Monotonically increasing node ID allocator. */
+    nextNodeId: number;
+    /** Total number of index entries. */
+    size: number;
+}
+/** Maximum keys per leaf node. Internal nodes hold ORDER-1 keys and ORDER children. */
+export declare const ORDER = 100;

package/dist/store/cache.d.ts

@@ -0,0 +1,17 @@
+export interface ICache<K, V> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): void;
+    has(key: K): boolean;
+    clear(): void;
+}
+export declare class LRUCache<K, V> implements ICache<K, V> {
+    private readonly capacity;
+    private readonly map;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): void;
+    has(key: K): boolean;
+    clear(): void;
+}