@depup/pg-mem 3.0.14-depup.0

package/package.json

@@ -0,0 +1,196 @@
+{
+  "name": "@depup/pg-mem",
+  "version": "3.0.14-depup.0",
+  "description": "A memory version of postgres (with updated dependencies)",
+  "main": "index.js",
+  "scripts": {
+    "build": "rimraf lib && NODE_OPTIONS=--openssl-legacy-provider webpack --config ./tools/webpack.config.js --prod && bun build-types",
+    "build-types": "rimraf lib/types && tsc --project tsconfig.json && copyfiles -u 2 \"lib-types/src/**/*.ts\" lib/types && rimraf lib/types/tests && rimraf lib-types && echo \"export * from './types';\" >> lib/index.d.ts",
+    "release": "bun release-node &&  bun release-deno",
+    "release-node": "git diff --exit-code && bun test && bun run build && bun build:deno && deno run tools/deno-test.ts && cd lib && npm publish && cd ..",
+    "release-deno": "git add -A && git commit -m \"Build deno [autogenerated commit]\" && PACKAGE_VERSION=$(cat package.json | grep \\\"version\\\" | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g' | tr -d '[[:space:]]') && git tag $PACKAGE_VERSION && git push --tags",
+    "start:playground": "NODE_OPTIONS=--openssl-legacy-provider webpack-dev-server --hot --config ./tools/playground.webpack.config.js",
+    "build:playground": "NODE_OPTIONS=--openssl-legacy-provider webpack --config ./tools/playground.webpack.config.js --prod",
+    "release:playground": "bun build:playground && cd dist && git init && git add -A && git commit -m\"initial\" && git remote add origin git@github.com:oguimbal/pg-mem-playground.git && git push --set-upstream origin master --force",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "test": "bun test",
+    "build:deno": "node ./tools/deno-transpile.js --copy && node ./tools/deno-transpile.js --process",
+    "cover": "NODE_OPTIONS=--openssl-legacy-provider cross-env NODE_ENV=coverage nyc --reporter=lcov --reporter=text bun test"
+  },
+  "author": "Olivier Guimbal",
+  "repository": "https://github.com/oguimbal/pg-mem",
+  "issues": "https://github.com/oguimbal/pg-mem/issues",
+  "keywords": [
+    "pg-mem",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "postgres",
+    "pg-mock",
+    "mock",
+    "memory",
+    "db",
+    "database",
+    "pg",
+    "typeorm",
+    "pg-promise",
+    "pg-native",
+    "unit test",
+    "ut",
+    "sql",
+    "pgsql",
+    "postgresql",
+    "knex",
+    "kysely"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "functional-red-black-tree": "^1.0.1",
+    "immutable": "^5.1.5",
+    "json-stable-stringify": "^1.3.0",
+    "lru-cache": "^11.2.7",
+    "moment": "^2.30.1",
+    "object-hash": "^3.0.0",
+    "pgsql-ast-parser": "^12.0.2"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.10.5",
+    "@babel/core": "^7.10.5",
+    "@babel/preset-env": "^7.10.4",
+    "@hot-loader/react-dom": "^16.13.0",
+    "@mikro-orm/core": "^5.8.1",
+    "@mikro-orm/postgresql": "^5.8.1",
+    "@types/json-stable-stringify": "^1.0.34",
+    "@types/lru-cache": "^5.1.0",
+    "@types/node": "^16.18.69",
+    "@types/object-hash": "^1.3.3",
+    "@types/pg": "^7.14.9",
+    "@types/react": "^16.9.43",
+    "@types/uuid": "^8.3.0",
+    "babel": "^6.23.0",
+    "babel-loader": "^8.1.0",
+    "babel-preset-react-app": "^9.1.2",
+    "bun-types": "^1.1.21",
+    "copy-webpack-plugin": "^6.0.3",
+    "copyfiles": "^2.4.0",
+    "cross-env": "^7.0.2",
+    "css-loader": "^4.1.0",
+    "dedent": "^0.7.0",
+    "file-loader": "^6.0.0",
+    "html-webpack-plugin": "^4.3.0",
+    "istanbul-instrumenter-loader": "^2.0.0",
+    "knex": "^2.5.1",
+    "kysely": "^0.26.3",
+    "monaco-editor": "^0.20.0",
+    "monaco-editor-webpack-plugin": "^1.9.0",
+    "nyc": "^15.1.0",
+    "pg": "^8.5.1",
+    "pg-promise": "^10.8.7",
+    "pg-server": "0.1.8",
+    "postgres": "^3.4.4",
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1",
+    "react-hot-loader": "^4.12.21",
+    "react-monaco-editor": "^0.39.1",
+    "reactjs-popup": "^1.5.0",
+    "rimraf": "^3.0.2",
+    "sequelize": ">=6.3.5 <6.20.0",
+    "slonik": "45.6.0",
+    "source-map-support": "^0.5.19",
+    "style-loader": "^1.2.1",
+    "ts-loader": "^8.0.0",
+    "ts-node": "^10.8.0",
+    "typeorm": "0.2.29",
+    "typescript": "^5.5.4",
+    "uuid": "^8.3.2",
+    "webpack": "4.43.0",
+    "webpack-cli": "3.3.12",
+    "webpack-dev-server": "4.9.2",
+    "webpack-node-externals": "^1.7.2",
+    "zod": "^3.23.8"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": ">=4.5.3",
+    "@mikro-orm/postgresql": ">=4.5.3",
+    "knex": ">=0.20",
+    "kysely": ">=0.26",
+    "pg-promise": ">=10.8.7",
+    "slonik": ">=23.0.1",
+    "typeorm": ">=0.2.29",
+    "postgres": "^3.4.4",
+    "pg-server": "^0.1.5"
+  },
+  "peerDependenciesMeta": {
+    "pg-server": {
+      "optional": true
+    },
+    "postgres": {
+      "optional": true
+    },
+    "@mikro-orm/core": {
+      "optional": true
+    },
+    "@mikro-orm/postgresql": {
+      "optional": true
+    },
+    "pg-promise": {
+      "optional": true
+    },
+    "typeorm": {
+      "optional": true
+    },
+    "slonik": {
+      "optional": true
+    },
+    "knex": {
+      "optional": true
+    },
+    "kysely": {
+      "optional": true
+    },
+    "mikro-orm": {
+      "optional": true
+    }
+  },
+  "nyc": {
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "src/**/*.spec.ts"
+    ],
+    "instrument": false,
+    "sourceMap": false
+  },
+  "depup": {
+    "changes": {
+      "immutable": {
+        "from": "^4.3.4",
+        "to": "^5.1.5"
+      },
+      "json-stable-stringify": {
+        "from": "^1.0.1",
+        "to": "^1.3.0"
+      },
+      "lru-cache": {
+        "from": "^6.0.0",
+        "to": "^11.2.7"
+      },
+      "moment": {
+        "from": "^2.27.0",
+        "to": "^2.30.1"
+      },
+      "object-hash": {
+        "from": "^2.0.3",
+        "to": "^3.0.0"
+      }
+    },
+    "depsUpdated": 5,
+    "originalPackage": "pg-mem",
+    "originalVersion": "3.0.14",
+    "processedAt": "2026-03-19T03:04:37.001Z",
+    "smokeTest": "failed"
+  }
+}

package/readme.md

@@ -0,0 +1,297 @@
+<p align="center">
+  <a href="https://npmjs.org/package/pg-mem"><img src="http://img.shields.io/npm/v/pg-mem.svg"></a>
+  <a href="https://npmjs.org/package/pg-mem"><img src="https://img.shields.io/npm/dm/pg-mem.svg"></a>
+  <a href="https://david-dm.org/oguimbal/pg-mem"><img src="https://david-dm.org/oguimbal/pg-mem.svg"></a>
+  <img src="https://github.com/oguimbal/pg-mem/workflows/CI/badge.svg">
+</p>
+
+<p align="center">
+  <img src="./.github/pg_mem.png" width="200">
+</p>
+
+ <h3 align="center">pg-mem is an experimental in-memory emulation of a postgres database.</h3>
+
+<p align="center">
+❤ It works both in Node or in the browser.
+</p>
+
+<p align="center">
+⭐ this repo if you like this package, it helps to motivate me :)
+
+</p>
+
+<p align="center">
+  👉 See it in action with <a href="https://oguimbal.github.io/pg-mem-playground/">pg-mem playground</a>
+</p>
+
+- [Usage](#-usage)
+- [Features](#-features)
+- [Libraries adapters](#-libraries-adapters)
+- [Inspection](#-inspection)
+- [Development](#-development)
+- [FAQ](https://github.com/oguimbal/pg-mem/wiki/FAQ)
+
+# 📐 Usage
+
+## Using Node.js
+
+As always, it starts with an:
+
+```bash
+npm i pg-mem --save
+```
+
+Then, assuming you're using something like webpack, if you're targeting a browser:
+
+```typescript
+import { newDb } from "pg-mem";
+
+const db = newDb();
+db.public.many(/* put some sql here */);
+```
+
+## Using Deno
+
+Pretty straightforward :)
+
+```typescript
+import { newDb } from "https://deno.land/x/pg_mem/mod.ts";
+
+const db = newDb();
+db.public.many(/* put some sql here */);
+```
+
+## Only use the SQL syntax parser
+
+❤ Head to the [pgsql-ast-parser](https://github.com/oguimbal/pgsql-ast-parser) repo
+
+## ⚠ Disclaimer
+
+The sql syntax parser is [home-made](https://github.com/oguimbal/pgsql-ast-parser). Which means that some features are not implemented, and will be considered as invalid syntaxes.
+
+This lib is quite new, so forgive it if some obvious pg syntax is not supported !
+
+... And open an issue if you feel like a feature should be implemented :)
+
+Moreover, even if I wrote hundreds of tests, keep in mind that this implementation is a best effort to replicate PG.
+Keep an eye on your query results if you perform complex queries.
+Please file issues if some results seem incoherent with what should be returned.
+
+Finally, I invite you to read the below section to have an idea of you can or cannot do.
+
+# 🔍 Features
+
+## Rollback to a previous state
+
+`pg-mem` uses immutable data structures ([here](https://www.npmjs.com/package/immutable) and [here](https://www.npmjs.com/package/functional-red-black-tree)),
+which means that you can have restore points for free!
+
+This is super useful if you intend to use `pg-mem` to mock your database for unit tests.
+
+You could:
+
+1. Create your schema only once (which could be a heavy operation for a single unit test)
+2. Insert test data which will be shared by all test
+3. Create a restore point
+4. Run your tests with the same db instance, executing a `backup.restore()` before each test (which instantly resets db to the state it has after creating the restore point)
+
+Usage:
+
+```typescript
+const db = newDb();
+db.public.none(`create table test(id text);
+                insert into test values ('value');`);
+// create a restore point & mess with data
+const backup = db.backup();
+db.public.none(`update test set id='new value';`);
+// restore it !
+backup.restore();
+db.public.many(`select * from test`); // => {test: 'value'}
+```
+
+## Custom functions
+
+You can declare custom functions like this:
+
+```typescript
+db.public.registerFunction({
+  name: "say_hello",
+  args: [DataType.text],
+  returns: DataType.text,
+  implementation: (x) => "hello " + x,
+});
+```
+
+And then use them like in SQL `select say_hello('world')`.
+
+Custom functions support overloading and variadic arguments.
+
+⚠ However, the value you return is not type checked. It MUST correspond to the datatype you provided as 'returns' (it won't fail if not, but could lead to weird bugs).
+
+## Custom types
+
+Not all pg types are implemented in pg-mem.
+That said, most of the types are often equivalent to other types, with a format validation. pg-mem provides a way to register such types.
+
+For instance, lets say you'd like to register the MACADDR type, which is basically a string, with a format constraint.
+
+You can register it like this:
+
+```typescript
+db.public.registerEquivalentType({
+  name: "macaddr",
+  // which type is it equivalent to (will be able to cast it from it)
+  equivalentTo: DataType.text,
+  isValid(val: string) {
+    // check that it will be this format
+    return isValidMacAddress(val);
+  },
+});
+```
+
+Doing so, you'll be able to do things such as:
+
+```sql
+SELECT '08:00:2b:01:02:03:04:05'::macaddr; -- WORKS
+SELECT 'invalid'::macaddr; -- will throw a conversion error
+```
+
+If you feel your implementation of a type matches the standard, and would like to include it in pg-mem for others to enjoy it, please consider filing a pull request ! (tip: see the [INET](https://github.com/oguimbal/pg-mem/blob/master/src/datatypes/t-inet.ts) type implementation as an example, and the [pg_catalog index](https://github.com/oguimbal/pg-mem/blob/master/src/schema/pg-catalog/index.ts) where supported types are registered)
+
+## Extensions
+
+No native extension is implemented (pull requests are welcome), but you can define kind-of extensions like this:
+
+```typescript
+db.registerExtension("my-ext", (schema) => {
+  // install your ext in 'schema'
+  // ex:  schema.registerFunction(...)
+});
+```
+
+Statements like `create extension "my-ext"` will then be supported.
+
+# 📃 Libraries adapters
+
+pg-mem provides handy shortcuts to create instances of popular libraries that will be bound to pg-mem instead of a real postgres db.
+
+- pg-native
+- node-postgres (pg)
+- pg-promise (pgp)
+- slonik
+- typeorm
+- knex
+- kysely
+- mikro-orm
+
+[See the wiki for more details](https://github.com/oguimbal/pg-mem/wiki/Libraries-adapters)
+
+# 💥 Inspection
+
+## Intercept queries
+
+If you would like to hook your database, and return ad-hoc results, you can do so like this:
+
+```typescript
+const db = newDb();
+
+db.public.interceptQueries((sql) => {
+  if (sql === "select * from whatever") {
+    // intercept this statement, and return something custom:
+    return [{ something: 42 }];
+  }
+  // proceed to actual SQL execution for other requests.
+  return null;
+});
+```
+
+## Inspect a table
+
+You can manually inspect a table content using the `find()` method:
+
+```typescript
+for (const item of db.public.getTable<TItem>("mytable").find(itemTemplate)) {
+  console.log(item);
+}
+```
+
+## Manually insert items
+
+If you'd like to insert items manually into a table, you can do this like that:
+
+```typescript
+db.public.getTable<TItem>('mytable').insert({ /* item to insert */ }))
+```
+
+## Subscribe to events
+
+You can subscribe to some events, like:
+
+```typescript
+const db = newDb();
+
+// called on each successful sql request
+db.on("query", (sql) => {});
+// called on each failed sql request
+db.on("query-failed", (sql) => {});
+// called on schema changes
+db.on("schema-change", () => {});
+// called when a CREATE EXTENSION schema is encountered.
+db.on("create-extension", (ext) => {});
+```
+
+## Experimental events
+
+`pg-mem` implements a basic support for indices.
+
+These handlers are called when a request cannot be optimized using one of the created indices.
+
+However, a real postgres instance will be much smarter to optimize its requests... so when `pg-mem` says "this request does not use an index", dont take my word for it.
+
+```typescript
+// called when a table is iterated entirely (ex: 'select * from data where notIndex=3' triggers it)
+db.on('seq-scan', () => {});
+
+// same, but on a specific table
+db.getTable('myTable').on('seq-scan', () = {});
+
+// will be called if pg-mem did not find any way to optimize a join
+// (which leads to a O(n*m) lookup with the current implementation)
+db.on('catastrophic-join-optimization', () => {});
+```
+
+# 🙋‍♂️ FAQ
+
+- [Why this instead of Docker ?](https://github.com/oguimbal/pg-mem/wiki/FAQ#-why-use-pg-mem-instead-of-an-instance-of-postgres-in-docker-) _TLDR : It's faster. Docker is overkill._
+- [What if I need an extension like uuid-ossp ?](https://github.com/oguimbal/pg-mem/wiki/FAQ#-what-if-i-need-an-extension-like-uuid-ossp-) _TLDR: You can mock those_
+- [How to import my production schema in pg-mem ?](https://github.com/oguimbal/pg-mem/wiki/FAQ#-how-to-import-my-production-schema-in-pg-mem-) _TLDR: pg_dump with the right args_
+- [Does pg-mem supports sql migrations ?](https://github.com/oguimbal/pg-mem/wiki/FAQ#-does-pg-mem-support-sql-migrations-scripts-) _TLDR: yes._
+- [Does pg-mem supports plpgsql/other scripts/"create functions"/"do statements" ?](https://github.com/oguimbal/pg-mem/wiki/FAQ#-how-to-use-plpgsql-or-other-scripts-) _TLDR: kind of..._
+
+Detailed answers [in the wiki](https://github.com/oguimbal/pg-mem/wiki/FAQ)
+
+# ⚠️ Current limitations
+
+- Materialized views are implemented as views (meaning that they are always up-to-date, without needing them to refresh)
+- Indices implementations are basic
+- No support for timezones
+- All number-like types are all handled as javascript numbers, meaning that types like `numeric(x,y)` could not behave as expected.
+
+# 🐜 Development
+
+Pull requests are welcome :)
+
+Unit tests are ran using [Bun](https://bun.sh/), which you will have to install to run tests.
+
+## Run all tests
+
+```bash
+bun test
+```
+
+## Debug a test
+
+Using vscode:
+
+1. Add a `.only` on the test you'd like to debug
+2. Just hit F5 (or execute via the debugger tab), which should launch your test with debugger attached

package/types/adapters/adapters.d.ts

@@ -0,0 +1,37 @@
+import { LibAdapters, SlonikAdapterOptions, BindServerOptions, BindServerResult } from '../interfaces';
+import { _IDb } from '../interfaces-private';
+export declare function replaceQueryArgs$(this: void, sql: string, values: any[]): string;
+export declare class Adapters implements LibAdapters {
+    private db;
+    private _mikroPatched?;
+    constructor(db: _IDb);
+    createPg(queryLatency?: number): {
+        Pool: any;
+        Client: any;
+    };
+    /**
+     * @deprecated Use `createTypeormDataSource` instead.
+     */
+    createTypeormConnection(postgresOptions: any, queryLatency?: number): any;
+    createTypeormDataSource(postgresOptions: any, queryLatency?: number): any;
+    createSlonik(opts?: SlonikAdapterOptions): any;
+    createPgPromise(queryLatency?: number): any;
+    createPgNative(queryLatency?: number): {
+        new (): {
+            connect(a: any, b: any): Promise<void>;
+            connectSync(): void;
+            prepare(name: string, sql: string, npar: number, callback: any): Promise<void>;
+            prepareSync(name: string, sql: string, npar: number): void;
+            execute(name: string, a: any, b: any): Promise<void>;
+            executeSync(name: string, pars?: any): any[];
+            query(sql: string, b: any, c: any): Promise<void>;
+            querySync(sql: string, params: any[]): any[];
+        };
+    };
+    createKnex(queryLatency?: number, knexConfig?: object): any;
+    createKysely(queryLatency?: number, kyselyConfig?: object): any;
+    createMikroOrm(mikroOrmOptions: any, queryLatency?: number): Promise<any>;
+    createPostgresJsTag(queryLatency?: number): any;
+    bindServer(opts?: BindServerOptions): Promise<BindServerResult>;
+}
+//# sourceMappingURL=adapters.d.ts.map

package/types/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './adapters';
+//# sourceMappingURL=index.d.ts.map

package/types/adapters/pg-socket-adapter.d.ts

@@ -0,0 +1,30 @@
+import { _ISchema } from '../interfaces-private';
+export declare const socketAdapter: import("../utils").LazySync<(mem: _ISchema, queryLatency?: number) => {
+    readonly peer: any;
+    isTop: boolean;
+    setNoDelay(): void;
+    write(data: any, mcb1?: any, mcb2?: any): boolean;
+    end(): any;
+    destroySoon(): void;
+    connect(): any;
+    pause(): any;
+    resume(): any;
+    [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
+    addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    on<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    once<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    off<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    removeAllListeners(event?: string | symbol | undefined): any;
+    setMaxListeners(n: number): any;
+    getMaxListeners(): number;
+    listeners<K>(eventName: string | symbol): Function[];
+    rawListeners<K>(eventName: string | symbol): Function[];
+    emit<K>(eventName: string | symbol, ...args: any[]): boolean;
+    listenerCount<K>(eventName: string | symbol, listener?: Function | undefined): number;
+    prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): any;
+    eventNames(): (string | symbol)[];
+}>;
+export declare function bindPgServer(this: void, peer: any, mem: _ISchema, queryLatency?: number): void;
+//# sourceMappingURL=pg-socket-adapter.d.ts.map

package/types/column.d.ts

@@ -0,0 +1,27 @@
+import { _Column, IValue, _Transaction, SchemaField, nil, ISubscription, DropHandler } from './interfaces-private';
+import type { MemoryTable } from './table';
+import { Evaluator } from './evaluator';
+import { ColumnConstraint, AlterColumn } from 'pgsql-ast-parser';
+import { BIndex } from './schema/btree-index';
+export declare class ColRef implements _Column {
+    readonly table: MemoryTable;
+    expression: Evaluator;
+    name: string;
+    comment: string | nil;
+    default: IValue | nil;
+    notNull: boolean;
+    generated: boolean;
+    usedInIndexes: Set<BIndex>;
+    private drophandlers;
+    constructor(table: MemoryTable, expression: Evaluator, _schema: SchemaField, name: string);
+    addConstraints(clist: ColumnConstraint[], t: _Transaction): this;
+    private addNotNullConstraint;
+    rename(to: string, t: _Transaction): this;
+    alter(alter: AlterColumn, t: _Transaction): this;
+    private replaceExpression;
+    drop(t: _Transaction): void;
+    checkConstraints(toInsert: any, t: _Transaction): void;
+    setDefaults(toInsert: any, t: _Transaction): void;
+    onDrop(sub: DropHandler): ISubscription;
+}
+//# sourceMappingURL=column.d.ts.map

package/types/constraints/foreign-key.d.ts

@@ -0,0 +1,14 @@
+import { TableConstraintForeignKey } from 'pgsql-ast-parser';
+import { _IConstraint, _ITable, _Transaction } from '../interfaces-private';
+export declare class ForeignKey implements _IConstraint {
+    readonly name: string;
+    private unsubs;
+    private table;
+    private foreignTable;
+    get db(): import("../interfaces-private")._IDb;
+    get schema(): import("../interfaces-private")._ISchema;
+    constructor(name: string);
+    install(_t: _Transaction, cst: TableConstraintForeignKey, table: _ITable): this;
+    uninstall(t: _Transaction): void;
+}
+//# sourceMappingURL=foreign-key.d.ts.map

package/types/constraints/generated-from-expr.d.ts

@@ -0,0 +1,14 @@
+import { AlterColumnAddGenerated, Expr, nil } from 'pgsql-ast-parser';
+import { _Column, _IConstraint, _Transaction } from '../interfaces-private';
+export declare class GeneratedComputedConstraint implements _IConstraint {
+    readonly name: string | nil;
+    private column;
+    private expression;
+    private subs;
+    private get table();
+    private get schema();
+    constructor(name: string | nil, column: _Column, expression: Expr);
+    uninstall(t: _Transaction): void;
+    install(ct: _Transaction, _c: AlterColumnAddGenerated): void;
+}
+//# sourceMappingURL=generated-from-expr.d.ts.map

package/types/constraints/generated-identity.d.ts

@@ -0,0 +1,13 @@
+import { AlterColumnAddGenerated, nil } from 'pgsql-ast-parser';
+import { _Column, _IConstraint, _Transaction } from '../interfaces-private';
+export declare class GeneratedIdentityConstraint implements _IConstraint {
+    readonly name: string | nil;
+    private column;
+    private subs;
+    private get table();
+    private get schema();
+    constructor(name: string | nil, column: _Column);
+    uninstall(t: _Transaction): void;
+    install(ct: _Transaction, _c: AlterColumnAddGenerated): void;
+}
+//# sourceMappingURL=generated-identity.d.ts.map

package/types/constraints/index-cst.d.ts

@@ -0,0 +1,9 @@
+import { _IConstraint, _IIndex, _ITable, _Transaction } from '../interfaces-private';
+export declare class IndexConstraint implements _IConstraint {
+    readonly name: string;
+    readonly index: _IIndex;
+    private table;
+    constructor(name: string, index: _IIndex, table: _ITable);
+    uninstall(t: _Transaction): void;
+}
+//# sourceMappingURL=index-cst.d.ts.map

package/types/constraints/subscription.d.ts

@@ -0,0 +1,7 @@
+import { _IConstraint, _Transaction } from '../interfaces-private';
+export declare class SubscriptionConstraint implements _IConstraint {
+    readonly name: string;
+    readonly uninstall: (t: _Transaction) => void;
+    constructor(name: string, uninstall: (t: _Transaction) => void);
+}
+//# sourceMappingURL=subscription.d.ts.map

package/types/constraints/wrapped.d.ts

@@ -0,0 +1,9 @@
+import { _IConstraint, _Transaction } from '../interfaces-private';
+export declare class ConstraintWrapper implements _IConstraint {
+    private refs;
+    private inner;
+    constructor(refs: Map<string, _IConstraint>, inner: _IConstraint);
+    get name(): string | import("../interfaces").nil;
+    uninstall(t: _Transaction): void;
+}
+//# sourceMappingURL=wrapped.d.ts.map