@depup/pg-mem 3.0.14-depup.0

package/types/schema/information-schema/columns-list.d.ts

@@ -0,0 +1,13 @@
+import { _ITable, IValue, _IIndex, _Transaction } from '../../interfaces-private';
+import { Schema, nil } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class ColumnsListSchema extends ReadOnlyTable implements _ITable {
+    get ownSymbol(): symbol;
+    _schema: Schema;
+    entropy(t: _Transaction): number;
+    enumerate(t: _Transaction): Generator<any, void, undefined>;
+    make(table: _ITable, i: number, t: IValue): any;
+    hasItem(value: any): boolean;
+    getIndex(forValue: IValue): _IIndex | nil;
+}
+//# sourceMappingURL=columns-list.d.ts.map

package/types/schema/information-schema/constraint-column-usage.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class ConstraintColumnUsage extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=constraint-column-usage.d.ts.map

package/types/schema/information-schema/index.d.ts

@@ -0,0 +1,3 @@
+import { _IDb } from '../../interfaces-private';
+export declare function setupInformationSchema(db: _IDb): void;
+//# sourceMappingURL=index.d.ts.map

package/types/schema/information-schema/key-column-usage.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class KeyColumnUsage extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=key-column-usage.d.ts.map

package/types/schema/information-schema/table-constraints.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class TableConstraints extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=table-constraints.d.ts.map

package/types/schema/information-schema/table-list.d.ts

@@ -0,0 +1,14 @@
+import { _ITable, IValue, _IIndex, _Transaction } from '../../interfaces-private';
+import { Schema, nil } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class TablesSchema extends ReadOnlyTable implements _ITable {
+    get ownSymbol(): symbol;
+    isOriginOf(v: IValue): boolean;
+    _schema: Schema;
+    entropy(t: _Transaction): number;
+    enumerate(t: _Transaction): Generator<any, void, unknown>;
+    make(t: _ITable): any;
+    hasItem(value: any): boolean;
+    getIndex(forValue: IValue): _IIndex | nil;
+}
+//# sourceMappingURL=table-list.d.ts.map

package/types/schema/overload-resolver.d.ts

@@ -0,0 +1,17 @@
+import { _IType, _ArgDefDetails, nil, IValue } from '../interfaces-private';
+export interface HasSig {
+    name: string;
+    args: _ArgDefDetails[];
+    argsVariadic?: _IType | nil;
+}
+export declare class OverloadResolver<T extends HasSig> {
+    private implicitCastOnly;
+    private byName;
+    constructor(implicitCastOnly: boolean);
+    add(value: T, replaceIfExists: boolean): void;
+    getOverloads(name: string): T[];
+    remove(value: T): void;
+    resolve(name: string, args: IValue[]): nil | T;
+    getExact(name: string, types: _IType[]): T | nil;
+}
+//# sourceMappingURL=overload-resolver.d.ts.map

package/types/schema/pg-catalog/binary-operators.d.ts

@@ -0,0 +1,3 @@
+import { _ISchema } from '../../interfaces-private';
+export declare function registerCommonOperators(schema: _ISchema): void;
+//# sourceMappingURL=binary-operators.d.ts.map

package/types/schema/pg-catalog/index.d.ts

@@ -0,0 +1,3 @@
+import { _IDb } from '../../interfaces-private';
+export declare function setupPgCatalog(db: _IDb): void;
+//# sourceMappingURL=index.d.ts.map

package/types/schema/pg-catalog/pg-attribute-list.d.ts

@@ -0,0 +1,11 @@
+import { _ITable, IValue, _IIndex } from '../../interfaces-private';
+import { nil, Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgAttributeTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+    getIndex(forValue: IValue): _IIndex | nil;
+}
+//# sourceMappingURL=pg-attribute-list.d.ts.map

package/types/schema/pg-catalog/pg-class.d.ts

@@ -0,0 +1,13 @@
+import { _ITable, _IIndex, _Transaction } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgClassListTable extends ReadOnlyTable implements _ITable {
+    get ownSymbol(): symbol;
+    _schema: Schema;
+    entropy(t: _Transaction): number;
+    enumerate(): Generator<never, void, unknown>;
+    makeInedx(t: _IIndex): any;
+    makeTable(t: _ITable): any;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-class.d.ts.map

package/types/schema/pg-catalog/pg-constraints-list.d.ts

@@ -0,0 +1,13 @@
+import { _ITable, IValue, _IIndex, _Transaction } from '../../interfaces-private';
+import { nil, Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgConstraintTable extends ReadOnlyTable implements _ITable {
+    get ownSymbol(): symbol;
+    _schema: Schema;
+    entropy(t: _Transaction): number;
+    enumerate(t: _Transaction): Generator<any, void, undefined>;
+    make(table: _ITable, i: number, t: IValue): any;
+    hasItem(value: any): boolean;
+    getIndex(forValue: IValue): _IIndex | nil;
+}
+//# sourceMappingURL=pg-constraints-list.d.ts.map

package/types/schema/pg-catalog/pg-database.d.ts

@@ -0,0 +1,17 @@
+import { _ITable, _Transaction } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+declare const IS_SCHEMA: unique symbol;
+export declare class PgDatabaseTable extends ReadOnlyTable implements _ITable {
+    get ownSymbol(): symbol;
+    _schema: Schema;
+    entropy(t: _Transaction): number;
+    enumerate(): Generator<{
+        oid: number;
+        datname: string;
+        [IS_SCHEMA]: boolean;
+    }, void, unknown>;
+    hasItem(value: any): boolean;
+}
+export {};
+//# sourceMappingURL=pg-database.d.ts.map

package/types/schema/pg-catalog/pg-enum-list.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgEnumTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-enum-list.d.ts.map

package/types/schema/pg-catalog/pg-index-list.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgIndexTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-index-list.d.ts.map

package/types/schema/pg-catalog/pg-namespace-list.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgNamespaceTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-namespace-list.d.ts.map

package/types/schema/pg-catalog/pg-proc.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgProc extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-proc.d.ts.map

package/types/schema/pg-catalog/pg-range.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgRange extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-range.d.ts.map

package/types/schema/pg-catalog/pg-sequences-list.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgSequencesTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-sequences-list.d.ts.map

package/types/schema/pg-catalog/pg-type-list.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgTypeTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-type-list.d.ts.map

package/types/schema/pg-catalog/pg-user-list.d.ts

@@ -0,0 +1,10 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+export declare class PgUserTable extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<never, void, unknown>;
+    hasItem(value: any): boolean;
+}
+//# sourceMappingURL=pg-user-list.d.ts.map

package/types/schema/pg-catalog/pg_statio_user_tables.d.ts

@@ -0,0 +1,25 @@
+import { _ITable } from '../../interfaces-private';
+import { Schema } from '../../interfaces';
+import { ReadOnlyTable } from '../readonly-table';
+declare const IS_SCHEMA: unique symbol;
+export declare class PgStatioUserTables extends ReadOnlyTable implements _ITable {
+    _schema: Schema;
+    entropy(): number;
+    enumerate(): Generator<{
+        relid: number;
+        schemaname: string;
+        relname: string;
+        heap_blks_read: number;
+        heap_blks_hit: number;
+        idx_blks_read: number;
+        idx_blks_hit: number;
+        toast_blks_read: number;
+        toast_blks_hit: number;
+        tidx_blks_read: number;
+        tidx_blks_hit: number;
+        [IS_SCHEMA]: boolean;
+    }, void, unknown>;
+    hasItem(value: any): boolean;
+}
+export {};
+//# sourceMappingURL=pg_statio_user_tables.d.ts.map

package/types/schema/pg-catalog/sql-function-language.d.ts

@@ -0,0 +1,3 @@
+import { _IDb } from '../../interfaces-private';
+export declare function registerSqlFunctionLanguage(db: _IDb): void;
+//# sourceMappingURL=sql-function-language.d.ts.map

package/types/schema/prepared-intercepted.d.ts

@@ -0,0 +1,11 @@
+import { IBoundQuery, IPreparedQuery, QueryDescription, QueryResult } from '../interfaces';
+export declare class InterceptedPreparedQuery implements IPreparedQuery, IBoundQuery {
+    private command;
+    private result;
+    constructor(command: string, result: any[]);
+    describe(): QueryDescription;
+    bind(args?: any[]): IBoundQuery;
+    iterate(): IterableIterator<QueryResult>;
+    executeAll(): QueryResult;
+}
+//# sourceMappingURL=prepared-intercepted.d.ts.map

package/types/schema/prepared.d.ts

@@ -0,0 +1,5 @@
+import { Statement } from 'pgsql-ast-parser';
+import { _IPreparedQuery, _ISchema, nil, Parameter } from '../interfaces-private';
+export declare function collectParams(stmt: Statement[]): Parameter[] | null;
+export declare function prepareQuery(schema: _ISchema, query: Statement[], singleSql: string | nil): _IPreparedQuery;
+//# sourceMappingURL=prepared.d.ts.map

package/types/schema/readonly-table.d.ts

@@ -0,0 +1,62 @@
+import { _ITable, _ISelection, _ISchema, _Transaction, _IIndex, IValue, _Column, SchemaField, IndexDef, _Explainer, _SelectExplanation, ChangeHandler, Stats, DropHandler, IndexHandler, Reg, _IConstraint, TruncateHandler, Row } from '../interfaces-private';
+import { CreateColumnDef, ExprRef, TableConstraint } from 'pgsql-ast-parser';
+import { DataSourceBase } from '../transforms/transform-base';
+import { Schema, nil, ISubscription, ColumnDef } from '../interfaces';
+export declare abstract class ReadOnlyTable extends DataSourceBase implements _ITable, _ISelection {
+    private schema;
+    get isExecutionWithNoResult(): boolean;
+    get primaryIndex(): nil | IndexDef;
+    getColumns(): Iterable<ColumnDef>;
+    abstract entropy(t: _Transaction): number;
+    abstract enumerate(t: _Transaction): Iterable<Row>;
+    abstract hasItem(value: Row, t: _Transaction): boolean;
+    abstract readonly _schema: Schema;
+    reg: Reg;
+    readonly selection: _ISelection;
+    readonly hidden = true;
+    isOriginOf(v: IValue): boolean;
+    get type(): "table";
+    constructor(schema: _ISchema);
+    get name(): string;
+    register(): void;
+    private columnsById;
+    private _columns?;
+    private build;
+    protected buildColumnEvaluator(_col: SchemaField, idx: number): IValue;
+    get columns(): ReadonlyArray<IValue>;
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    explain(e: _Explainer): _SelectExplanation;
+    listIndices(): IndexDef[];
+    stats(t: _Transaction): Stats | null;
+    rename(to: string): this;
+    update(t: _Transaction, toUpdate: any): never;
+    addColumn(column: SchemaField | CreateColumnDef): _Column;
+    getColumnRef(column: string, nullIfNotFound?: boolean): _Column;
+    getConstraint(constraint: string): _IConstraint | nil;
+    addConstraint(constraint: TableConstraint, t: _Transaction): _IConstraint;
+    insert(item: any): void;
+    doInsert(toInsert: any): void;
+    delete(t: _Transaction, toDelete: Row): void;
+    truncate(t: _Transaction): void;
+    createIndex(): _IConstraint;
+    dropIndex(t: _Transaction, name: string): void;
+    setHidden(): this;
+    drop(t: _Transaction): void;
+    setReadonly(): this;
+    getIndex(...forValue: IValue[]): _IIndex | nil;
+    on(): any;
+    onBeforeChange(columns: 'all' | (string | _Column)[], check: ChangeHandler): {
+        unsubscribe(): void;
+    };
+    onCheckChange(columns: string[], check: ChangeHandler): {
+        unsubscribe(): void;
+    };
+    onTruncate(sub: TruncateHandler): ISubscription;
+    onDrop(sub: DropHandler): ISubscription;
+    onIndex(sub: IndexHandler): ISubscription;
+    find(template?: Row, columns?: (keyof Row)[]): Row[];
+    make(table: _ITable, i: number, t: IValue): any;
+    itemsByTable(table: string | _ITable, t: _Transaction): IterableIterator<any>;
+}
+//# sourceMappingURL=readonly-table.d.ts.map

package/types/schema/schema.d.ts

@@ -0,0 +1,73 @@
+import { ISchema, DataType, IType, Schema, QueryResult, nil, FunctionDefinition, IEquivalentType, QueryInterceptor, ISubscription, OperatorDefinition, QueryOrAst, IPreparedQuery } from '../interfaces';
+import { _IDb, _ISelection, _ISchema, _Transaction, _ITable, _SelectExplanation, IValue, _IType, _IRelation, QueryObjOpts, _ISequence, RegClass, Reg, TypeQuery, BeingCreated, _FunctionDefinition, _OperatorDefinition } from '../interfaces-private';
+import { DropFunctionStatement, BinaryOperator, QName, DataTypeDef, CreateSequenceOptions, CreateExtensionStatement } from 'pgsql-ast-parser';
+import { MemoryTable } from '../table';
+import { MigrationParams } from '../migrate/migrate-interfaces';
+export declare class DbSchema implements _ISchema, ISchema {
+    readonly name: string;
+    readonly db: _IDb;
+    readonly dualTable: _ITable;
+    private relsByNameCas;
+    private relsByCls;
+    private relsByTyp;
+    private _tables;
+    private fns;
+    private ops;
+    private installedExtensions;
+    private readonly;
+    private interceptors;
+    lastSelect?: _ISelection;
+    constructor(name: string, db: _IDb);
+    setReadonly(): this;
+    none(query: QueryOrAst): void;
+    one(query: QueryOrAst): any;
+    many(query: QueryOrAst): any[];
+    query(text: QueryOrAst): QueryResult;
+    prepare(query: QueryOrAst): IPreparedQuery;
+    private parse;
+    queries(query: QueryOrAst): Iterable<QueryResult>;
+    registerEnum(name: string, values: string[]): void;
+    getThisOrSiblingFor(name: QName): _ISchema;
+    private simpleTypes;
+    private sizeableTypes;
+    parseType(native: string): _IType;
+    getOwnType(t: DataTypeDef): _IType | null;
+    getTypePub(t: DataType | IType): _IType;
+    getType(t: TypeQuery): _IType;
+    getObject(p: QName): _IRelation;
+    getObject(p: QName, opts: BeingCreated): _IRelation;
+    getObject(p: QName, opts?: QueryObjOpts): _IRelation | null;
+    getOwnObject(name: string): _IRelation | null;
+    getObjectByRegOrName(reg: RegClass): _IRelation;
+    getObjectByRegOrName(reg: RegClass, opts?: QueryObjOpts): _IRelation | null;
+    getObjectByRegClassId(reg: number): _IRelation;
+    getObjectByRegClassId(reg: number, opts?: QueryObjOpts): _IRelation | null;
+    getOwnObjectByRegClassId(reg: number): _IRelation | null;
+    createSequence(t: _Transaction, opts: CreateSequenceOptions | nil, _name: QName | nil): _ISequence;
+    explainLastSelect(): _SelectExplanation | undefined;
+    explainSelect(sql: string): _SelectExplanation;
+    executeCreateExtension(p: CreateExtensionStatement): void;
+    getTable(name: string): _ITable;
+    getTable(name: string, nullIfNotFound?: boolean): _ITable | null;
+    declareTable(table: Schema, noSchemaChange?: boolean): MemoryTable;
+    registerEquivalentType(type: IEquivalentType): IType;
+    registerEquivalentSizableType(type: IEquivalentType): IType;
+    _registerTypeSizeable(name: string, ctor: (sz?: number) => _IType): this;
+    _registerType(type: _IType): this;
+    _unregisterType(type: _IType): this;
+    _reg_register(rel: _IRelation): Reg;
+    _reg_unregister(rel: _IRelation): void;
+    _reg_rename(rel: _IRelation, oldName: string, newName: string): void;
+    tablesCount(t: _Transaction): number;
+    listTables(): Iterable<_ITable>;
+    registerFunction(fn: FunctionDefinition, replace?: boolean): this;
+    registerOperator(op: OperatorDefinition, replace?: boolean): this;
+    private _registerOperator;
+    resolveFunction(name: string | QName, args: IValue[], forceOwn?: boolean): _FunctionDefinition | nil;
+    getFunction(name: string, args: _IType[]): _FunctionDefinition | nil;
+    dropFunction(fn: DropFunctionStatement): void;
+    resolveOperator(name: BinaryOperator, left: IValue, right: IValue, forceOwn?: boolean): _OperatorDefinition | nil;
+    migrate(config?: MigrationParams): Promise<void>;
+    interceptQueries(intercept: QueryInterceptor): ISubscription;
+}
+//# sourceMappingURL=schema.d.ts.map

package/types/schema/sequence.d.ts

@@ -0,0 +1,27 @@
+import { AlterSequenceChange, CreateSequenceOptions } from 'pgsql-ast-parser';
+import { _ISchema, _ISequence, _IType, _Transaction, Reg } from '../interfaces-private';
+import { nil } from '../interfaces';
+export declare class Sequence implements _ISequence {
+    name: string;
+    readonly ownerSchema: _ISchema;
+    get type(): 'sequence';
+    private symbol;
+    private owner?;
+    private cfg;
+    readonly reg: Reg;
+    get cycle(): boolean;
+    get dataType(): _IType<any>;
+    get inc(): number;
+    constructor(name: string, ownerSchema: _ISchema);
+    get start(): number;
+    get max(): number;
+    get min(): number;
+    alter(t: _Transaction, opts: CreateSequenceOptions | AlterSequenceChange | nil): this;
+    nextValue(t: _Transaction): number;
+    setValue(t: _Transaction, value: number, increase?: boolean): void;
+    restart(t: _Transaction): void;
+    currentValue(t: _Transaction): number;
+    private alterOpts;
+    drop(t: _Transaction): void;
+}
+//# sourceMappingURL=sequence.d.ts.map

package/types/schema/table-index.d.ts

@@ -0,0 +1,32 @@
+import { _IIndex, IValue, _ITable, _Transaction, _Explainer, _IndexExplanation, IndexOp, IndexKey, Stats } from '../interfaces-private';
+export declare class TableIndex implements _IIndex {
+    readonly onTable: _ITable & {
+        itemsByTable(table: string, t: _Transaction): Iterable<any>;
+        ownSymbol: any;
+    };
+    private col;
+    readonly expressions: IValue[];
+    get hash(): string;
+    explain(e: _Explainer): _IndexExplanation;
+    stats(t: _Transaction, key?: IndexKey): Stats | null;
+    iterateKeys(): null;
+    constructor(onTable: _ITable & {
+        itemsByTable(table: string, t: _Transaction): Iterable<any>;
+        ownSymbol: any;
+    }, col: IValue);
+    get indexName(): string;
+    entropy(op: IndexOp): number;
+    add(raw: any): void;
+    eqFirst([key]: any, t: _Transaction): any;
+    eq([rawKey]: any, t: _Transaction): Iterable<any>;
+    nin(keys: any[][], t: _Transaction): Generator<any, void, unknown>;
+    neq([rawKey]: any, t: _Transaction): Generator<any, void, unknown>;
+    gt(rawKey: any, t: _Transaction): Iterable<any>;
+    lt(rawKey: any, t: _Transaction): Iterable<any>;
+    ge(rawKey: any, t: _Transaction): Iterable<any>;
+    le(rawKey: any, t: _Transaction): Iterable<any>;
+    enumerate(op: IndexOp): Iterable<any>;
+    outside(lo: IndexKey, hi: IndexKey, t: _Transaction): Iterable<any>;
+    inside(lo: IndexKey, hi: IndexKey, t: _Transaction): Iterable<any>;
+}
+//# sourceMappingURL=table-index.d.ts.map

package/types/schema/values-table.d.ts

@@ -0,0 +1,16 @@
+import { nil, Schema, SchemaField } from '../interfaces';
+import { IValue, _Transaction } from '../interfaces-private';
+import { Expr } from 'pgsql-ast-parser';
+import { ReadOnlyTable } from './readonly-table';
+export declare class ValuesTable extends ReadOnlyTable {
+    private symbol;
+    _schema: Schema;
+    private assignments;
+    entropy(t: _Transaction): number;
+    enumerate(t: _Transaction): Iterable<any>;
+    hasItem(value: any, t: _Transaction): boolean;
+    /** @override */
+    protected buildColumnEvaluator(_col: SchemaField, i: number): IValue;
+    constructor(alias: string, items: Expr[][], columnNames: string[] | nil, acceptDefault?: boolean);
+}
+//# sourceMappingURL=values-table.d.ts.map

package/types/schema/view.d.ts

@@ -0,0 +1,18 @@
+import { Reg, _Explainer, _ISchema, _ISelection, _IView, _Transaction } from '../interfaces-private';
+import { FilterBase } from '../transforms/transform-base';
+export declare class View extends FilterBase implements _IView {
+    readonly ownerSchema: _ISchema;
+    readonly name: string;
+    readonly selection: _ISelection;
+    get type(): 'view';
+    private _reg?;
+    get reg(): Reg;
+    constructor(ownerSchema: _ISchema, name: string, selection: _ISelection);
+    enumerate(t: _Transaction): Iterable<any>;
+    hasItem(value: any, t: _Transaction): boolean;
+    explain(e: _Explainer): import("../interfaces-private")._SelectExplanation;
+    stats(t: _Transaction): import("../interfaces-private").Stats | null;
+    register(): this;
+    drop(t: _Transaction): void;
+}
+//# sourceMappingURL=view.d.ts.map

package/types/table.d.ts

@@ -0,0 +1,97 @@
+import { IMemoryTable, Schema, TableEvent, IndexDef, ISubscription, nil, ColumnDef } from './interfaces';
+import { IValue, _ITable, CreateIndexDef, _Transaction, _ISchema, _Column, SchemaField, _IIndex, _Explainer, _SelectExplanation, ChangeHandler, Stats, DropHandler, IndexHandler, Reg, ChangeOpts, _IConstraint, TruncateHandler, TruncateOpts, Row } from './interfaces-private';
+import { Map as ImMap } from 'immutable';
+import { CreateColumnDef, TableConstraintForeignKey, TableConstraint, Expr, Name, ExprRef } from 'pgsql-ast-parser';
+import { ColRef } from './column';
+import { Alias } from './transforms/alias';
+import { DataSourceBase } from './transforms/transform-base';
+type Raw = ImMap<string, Row>;
+declare class ColumnManager {
+    private _columns?;
+    readonly map: Map<string, ColRef>;
+    get columns(): readonly IValue[];
+    invalidateColumns(): void;
+    get: (key: string) => ColRef | undefined;
+    has: (key: string) => boolean;
+    values: () => IterableIterator<ColRef>;
+    set(name: string, colDef: ColRef): Map<string, ColRef>;
+    delete(name: string): boolean;
+}
+export declare class MemoryTable extends DataSourceBase implements IMemoryTable<any>, _ITable {
+    comment: string | nil;
+    get isExecutionWithNoResult(): boolean;
+    private handlers;
+    readonly selection: Alias;
+    private _reg?;
+    get reg(): Reg;
+    get columns(): readonly IValue<any>[];
+    private it;
+    private cstGen;
+    private hasPrimary;
+    private readonly;
+    hidden: boolean;
+    private dataId;
+    private serialsId;
+    private constraintsByName;
+    private indexByHashAndName;
+    readonly columnMgr: ColumnManager;
+    name: string;
+    private changeHandlers;
+    private truncateHandlers;
+    private drophandlers;
+    private indexHandlers;
+    get type(): "table";
+    get debugId(): string;
+    entropy(t: _Transaction): number;
+    isOriginOf(a: IValue): boolean;
+    constructor(schema: _ISchema, t: _Transaction, _schema: Schema);
+    register(): this;
+    stats(t: _Transaction): Stats | null;
+    rename(name: string): this;
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    explain(e: _Explainer): _SelectExplanation;
+    addColumn(column: SchemaField | CreateColumnDef, t: _Transaction): _Column;
+    getColumnRef(column: string): ColRef;
+    getColumnRef(column: string, nullIfNotFound?: boolean): ColRef | nil;
+    bin(t: _Transaction): Raw;
+    setBin(t: _Transaction, val: Raw): Raw;
+    on(event: TableEvent, handler: () => any): ISubscription;
+    raise(event: TableEvent): void;
+    setReadonly(): this;
+    setHidden(): this;
+    enumerate(t: _Transaction): Iterable<Row>;
+    find(template?: Row, columns?: (keyof Row)[]): Row[];
+    remapData(t: _Transaction, modify: (newCopy: Row) => any): void;
+    insert(toInsert: Row): Row | null;
+    doInsert(t: _Transaction, toInsert: Row, opts?: ChangeOpts): Row | null;
+    private changePlan;
+    update(t: _Transaction, toUpdate: Row): Row;
+    delete(t: _Transaction, toDelete: Row): any;
+    truncate(t: _Transaction, _opts?: TruncateOpts): void;
+    private indexElt;
+    hasItem(item: Row, t: _Transaction): boolean;
+    getIndex(...forValues: IValue[]): _IIndex | nil;
+    constraintNameGen(constraintName?: string): string;
+    addCheck(_t: _Transaction, check: Expr, constraintName?: string): _IConstraint;
+    createIndex(t: _Transaction, expressions: CreateIndexDef): _IConstraint | nil;
+    createIndex(t: _Transaction, expressions: Name[], type: 'primary' | 'unique', indexName?: string | nil): _IConstraint;
+    private determineIndexRelName;
+    dropIndex(t: _Transaction, uName: string): void;
+    onIndex(sub: IndexHandler): ISubscription;
+    listIndices(): IndexDef[];
+    get primaryIndex(): IndexDef | null;
+    addForeignKey(cst: TableConstraintForeignKey, t: _Transaction): _IConstraint | nil;
+    getConstraint(constraint: string): _IConstraint | nil;
+    addConstraint(cst: TableConstraint, t: _Transaction): _IConstraint | nil;
+    private checkNoConstraint;
+    onBeforeChange(columns: 'all' | (string | _Column)[], check: ChangeHandler): ISubscription;
+    onCheckChange(columns: string[], check: ChangeHandler): ISubscription;
+    getColumns(): Iterable<ColumnDef>;
+    private _subChange;
+    drop(t: _Transaction, cascade: boolean): void;
+    onDrop(sub: DropHandler): ISubscription;
+    onTruncate(sub: TruncateHandler): ISubscription;
+}
+export {};
+//# sourceMappingURL=table.d.ts.map