@immich/sql-tools 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,946 @@
+import { ColumnType as ColumnType_2 } from 'kysely';
+import { Kysely } from 'kysely';
+import { Sql } from 'postgres';
+
+export declare enum ActionType {
+    NO_ACTION = "NO ACTION",
+    RESTRICT = "RESTRICT",
+    CASCADE = "CASCADE",
+    SET_NULL = "SET NULL",
+    SET_DEFAULT = "SET DEFAULT"
+}
+
+export declare const AfterDeleteTrigger: (options: Omit<TriggerFunctionOptions, "timing" | "actions">) => ClassDecorator;
+
+export declare const AfterInsertTrigger: (options: Omit<TriggerFunctionOptions, "timing" | "actions">) => ClassDecorator;
+
+declare class BaseContext {
+    databaseName: string;
+    schemaName: string;
+    overrideTableName: string;
+    tables: DatabaseTable[];
+    functions: DatabaseFunction[];
+    enums: DatabaseEnum[];
+    extensions: DatabaseExtension[];
+    parameters: DatabaseParameter[];
+    overrides: DatabaseOverride[];
+    warnings: string[];
+    private namingStrategy;
+    constructor(options: BaseContextOptions);
+    getNameFor(item: NamingItem): string;
+    getTableByName(name: string): DatabaseTable | undefined;
+    warn(context: string, message: string): void;
+    build(): DatabaseSchema;
+}
+
+export declare type BaseContextOptions = {
+    databaseName?: string;
+    schemaName?: string;
+    overrideTableName?: string;
+    namingStrategy?: 'default' | 'hash' | NamingInterface;
+};
+
+export declare const BeforeUpdateTrigger: (options: Omit<TriggerFunctionOptions, "timing" | "actions">) => ClassDecorator;
+
+export declare const Check: (options: CheckOptions) => ClassDecorator;
+
+export declare type CheckOptions = {
+    name?: string;
+    expression: string;
+    synchronize?: boolean;
+};
+
+declare type ClassBased<T> = {
+    object: Function;
+} & T;
+
+declare type ColumBasedConstraint = {
+    name: string;
+    tableName: string;
+    columnNames: string[];
+};
+
+export declare const Column: (options?: string | ColumnOptions) => PropertyDecorator;
+
+export declare type ColumnBaseOptions = {
+    name?: string;
+    primary?: boolean;
+    type?: ColumnType;
+    nullable?: boolean;
+    length?: number;
+    default?: ColumnValue;
+    comment?: string;
+    synchronize?: boolean;
+    storage?: ColumnStorage;
+    identity?: boolean;
+    index?: boolean;
+    indexName?: string;
+    unique?: boolean;
+    uniqueConstraintName?: string;
+};
+
+export declare type ColumnChanges = {
+    nullable?: boolean;
+    default?: string;
+    comment?: string;
+    storage?: ColumnStorage;
+};
+
+export declare type ColumnOptions = ColumnBaseOptions & {
+    enum?: DatabaseEnum;
+    array?: boolean;
+};
+
+export declare type ColumnStorage = 'default' | 'external' | 'extended' | 'main';
+
+export declare type ColumnType = 'bigint' | 'boolean' | 'bytea' | 'character' | 'character varying' | 'date' | 'double precision' | 'integer' | 'jsonb' | 'polygon' | 'text' | 'time' | 'time with time zone' | 'time without time zone' | 'timestamp' | 'timestamp with time zone' | 'timestamp without time zone' | 'uuid' | 'vector' | 'enum' | 'serial' | 'real';
+
+export declare type ColumnValue = null | boolean | string | number | Array<unknown> | object | Date | (() => string);
+
+export declare type CompareFunction<T> = (source: T, target: T) => SchemaDiff[];
+
+export declare type Comparer<T> = {
+    onMissing: (source: T) => SchemaDiff[];
+    onExtra: (target: T) => SchemaDiff[];
+    onCompare: CompareFunction<T>;
+    /** if two items have the same key, they are considered identical and can be renamed via `onRename` */
+    getRenameKey?: (item: T) => string;
+    onRename?: (source: T, target: T) => SchemaDiff[];
+};
+
+export declare const ConfigurationParameter: (options: ConfigurationParameterOptions) => ClassDecorator;
+
+export declare type ConfigurationParameterOptions = {
+    name: string;
+    value: ColumnValue;
+    scope: ParameterScope;
+    synchronize?: boolean;
+};
+
+export declare enum ConstraintType {
+    PRIMARY_KEY = "primary-key",
+    FOREIGN_KEY = "foreign-key",
+    UNIQUE = "unique",
+    CHECK = "check"
+}
+
+export declare const CreateDateColumn: (options?: ColumnOptions) => PropertyDecorator;
+
+export declare const Database: (options: DatabaseOptions) => ClassDecorator;
+
+export declare type DatabaseCheckConstraint = {
+    type: ConstraintType.CHECK;
+    name: string;
+    tableName: string;
+    expression: string;
+    synchronize: boolean;
+};
+
+export declare type DatabaseClient = Kysely<PostgresDB>;
+
+export declare type DatabaseColumn = {
+    primary: boolean;
+    name: string;
+    tableName: string;
+    comment?: string;
+    type: ColumnType;
+    nullable: boolean;
+    isArray: boolean;
+    synchronize: boolean;
+    default?: string;
+    length?: number;
+    storage?: ColumnStorage;
+    identity?: boolean;
+    enumName?: string;
+    numericPrecision?: number;
+    numericScale?: number;
+};
+
+export declare type DatabaseConstraint = DatabasePrimaryKeyConstraint | DatabaseForeignKeyConstraint | DatabaseUniqueConstraint | DatabaseCheckConstraint;
+
+export declare type DatabaseEnum = {
+    name: string;
+    values: string[];
+    synchronize: boolean;
+};
+
+export declare type DatabaseExtension = {
+    name: string;
+    synchronize: boolean;
+};
+
+export declare type DatabaseForeignKeyConstraint = ColumBasedConstraint & {
+    type: ConstraintType.FOREIGN_KEY;
+    referenceTableName: string;
+    referenceColumnNames: string[];
+    onUpdate?: ActionType;
+    onDelete?: ActionType;
+    synchronize: boolean;
+};
+
+export declare type DatabaseFunction = {
+    name: string;
+    expression: string;
+    synchronize: boolean;
+    override?: DatabaseOverride;
+};
+
+export declare type DatabaseIndex = {
+    name: string;
+    tableName: string;
+    columnNames?: string[];
+    expression?: string;
+    unique: boolean;
+    using?: string;
+    with?: string;
+    where?: string;
+    override?: DatabaseOverride;
+    synchronize: boolean;
+};
+
+declare type DatabaseLike = Sql | Kysely<any>;
+
+export declare type DatabaseOptions = {
+    name?: string;
+    synchronize?: boolean;
+};
+
+export declare type DatabaseOverride = {
+    name: string;
+    value: {
+        name: string;
+        type: OverrideType;
+        sql: string;
+    };
+    synchronize: boolean;
+};
+
+export declare type DatabaseParameter = {
+    name: string;
+    databaseName: string;
+    value: string | number | null | undefined;
+    scope: ParameterScope;
+    synchronize: boolean;
+};
+
+export declare type DatabasePrimaryKeyConstraint = ColumBasedConstraint & {
+    type: ConstraintType.PRIMARY_KEY;
+    synchronize: boolean;
+};
+
+export declare type DatabaseSchema = {
+    databaseName: string;
+    schemaName: string;
+    functions: DatabaseFunction[];
+    enums: DatabaseEnum[];
+    tables: DatabaseTable[];
+    extensions: DatabaseExtension[];
+    parameters: DatabaseParameter[];
+    overrides: DatabaseOverride[];
+    warnings: string[];
+};
+
+export declare type DatabaseTable = {
+    name: string;
+    columns: DatabaseColumn[];
+    indexes: DatabaseIndex[];
+    constraints: DatabaseConstraint[];
+    triggers: DatabaseTrigger[];
+    synchronize: boolean;
+};
+
+export declare type DatabaseTrigger = {
+    name: string;
+    tableName: string;
+    timing: TriggerTiming;
+    actions: TriggerAction[];
+    scope: TriggerScope;
+    referencingNewTableAs?: string;
+    referencingOldTableAs?: string;
+    when?: string;
+    functionName: string;
+    override?: DatabaseOverride;
+    synchronize: boolean;
+};
+
+export declare type DatabaseUniqueConstraint = ColumBasedConstraint & {
+    type: ConstraintType.UNIQUE;
+    synchronize: boolean;
+};
+
+export declare class DefaultNamingStrategy {
+    getName(item: NamingItem): string;
+}
+
+export declare const DeleteDateColumn: (options?: ColumnOptions) => PropertyDecorator;
+
+export declare type EnumOptions = {
+    name: string;
+    values: string[];
+    synchronize?: boolean;
+};
+
+export declare const Extension: (options: string | ExtensionOptions) => ClassDecorator;
+
+export declare type ExtensionOptions = {
+    name: string;
+    synchronize?: boolean;
+};
+
+export declare const Extensions: (options: Array<string | ExtensionsOptions>) => ClassDecorator;
+
+export declare type ExtensionsOptions = {
+    name: string;
+    synchronize?: boolean;
+};
+
+export declare type ForeignKeyAction = 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+
+export declare const ForeignKeyColumn: (target: () => Function, options: ForeignKeyColumnOptions) => PropertyDecorator;
+
+export declare type ForeignKeyColumnOptions = ColumnBaseOptions & {
+    onUpdate?: ForeignKeyAction;
+    onDelete?: ForeignKeyAction;
+    constraintName?: string;
+};
+
+export declare const ForeignKeyConstraint: (options: ForeignKeyConstraintOptions) => ClassDecorator;
+
+export declare type ForeignKeyConstraintOptions = {
+    name?: string;
+    index?: boolean;
+    indexName?: string;
+    columns: string[];
+    referenceTable: () => Function;
+    referenceColumns?: string[];
+    onUpdate?: ForeignKeyAction;
+    onDelete?: ForeignKeyAction;
+    synchronize?: boolean;
+};
+
+export declare type FunctionOptions = {
+    name: string;
+    arguments?: string[];
+    returnType: ColumnType | string;
+    language?: 'SQL' | 'PLPGSQL';
+    behavior?: 'immutable' | 'stable' | 'volatile';
+    parallel?: 'safe' | 'unsafe' | 'restricted';
+    strict?: boolean;
+    synchronize?: boolean;
+} & ({
+    body: string;
+} | {
+    return: string;
+});
+
+export declare type GenerateColumnOptions = Omit<ColumnOptions, 'type'> & {
+    strategy?: GeneratedColumnStrategy;
+};
+
+export declare type Generated<T> = T extends ColumnType_2<infer S, infer I, infer U> ? ColumnType_2<S, I | undefined, U> : ColumnType_2<T, T | undefined, T>;
+
+export declare const GeneratedColumn: ({ strategy, ...options }: GenerateColumnOptions) => PropertyDecorator;
+
+export declare type GeneratedColumnStrategy = 'uuid' | 'identity';
+
+export declare class HashNamingStrategy implements NamingInterface {
+    getName(item: NamingItem): string;
+}
+
+export declare type IgnoreOptions = boolean | {
+    ignoreExtra?: boolean;
+    ignoreMissing?: boolean;
+};
+
+export declare const Index: (options?: string | IndexOptions) => ClassDecorator;
+
+export declare type IndexOptions = {
+    name?: string;
+    unique?: boolean;
+    expression?: string;
+    using?: string;
+    with?: string;
+    where?: string;
+    columns?: string[];
+    synchronize?: boolean;
+};
+
+export declare type Int8 = ColumnType_2<number>;
+
+export declare interface NamingInterface {
+    getName(item: NamingItem): string;
+}
+
+export declare type NamingItem = {
+    type: 'database';
+    name: string;
+} | {
+    type: 'table';
+    name: string;
+} | {
+    type: 'column';
+    name: string;
+} | {
+    type: 'primaryKey';
+    tableName: string;
+    columnNames: string[];
+} | {
+    type: 'foreignKey';
+    tableName: string;
+    columnNames: string[];
+    referenceTableName: string;
+    referenceColumnNames: string[];
+} | {
+    type: 'check';
+    tableName: string;
+    expression: string;
+} | {
+    type: 'unique';
+    tableName: string;
+    columnNames: string[];
+} | {
+    type: 'index';
+    tableName: string;
+    columnNames?: string[];
+    expression?: string;
+    where?: string;
+} | {
+    type: 'trigger';
+    tableName: string;
+    functionName: string;
+    actions: TriggerAction[];
+    scope: TriggerScope;
+    timing: TriggerTiming;
+    columnNames?: string[];
+    expression?: string;
+    where?: string;
+};
+
+export declare type OverrideType = 'function' | 'index' | 'trigger';
+
+export declare type ParameterScope = 'database' | 'user';
+
+export declare type PostgresDB = {
+    pg_am: {
+        oid: number;
+        amname: string;
+        amhandler: string;
+        amtype: string;
+    };
+    pg_attribute: {
+        attrelid: number;
+        attname: string;
+        attnum: number;
+        atttypeid: number;
+        attstattarget: number;
+        attstatarget: number;
+        aanum: number;
+    };
+    pg_class: {
+        oid: number;
+        relname: string;
+        relkind: string;
+        relnamespace: string;
+        reltype: string;
+        relowner: string;
+        relam: string;
+        relfilenode: string;
+        reltablespace: string;
+        relpages: number;
+        reltuples: number;
+        relallvisible: number;
+        reltoastrelid: string;
+        relhasindex: PostgresYesOrNo;
+        relisshared: PostgresYesOrNo;
+        relpersistence: string;
+    };
+    pg_constraint: {
+        oid: number;
+        conname: string;
+        conrelid: string;
+        contype: string;
+        connamespace: string;
+        conkey: number[];
+        confkey: number[];
+        confrelid: string;
+        confupdtype: string;
+        confdeltype: string;
+        confmatchtype: number;
+        condeferrable: PostgresYesOrNo;
+        condeferred: PostgresYesOrNo;
+        convalidated: PostgresYesOrNo;
+        conindid: number;
+    };
+    pg_description: {
+        objoid: string;
+        classoid: string;
+        objsubid: number;
+        description: string;
+    };
+    pg_trigger: {
+        oid: string;
+        tgisinternal: boolean;
+        tginitdeferred: boolean;
+        tgdeferrable: boolean;
+        tgrelid: string;
+        tgfoid: string;
+        tgname: string;
+        tgenabled: string;
+        tgtype: number;
+        tgconstraint: string;
+        tgdeferred: boolean;
+        tgargs: Buffer;
+        tgoldtable: string;
+        tgnewtable: string;
+        tgqual: string;
+    };
+    'pg_catalog.pg_extension': {
+        oid: string;
+        extname: string;
+        extowner: string;
+        extnamespace: string;
+        extrelocatable: boolean;
+        extversion: string;
+        extconfig: string[];
+        extcondition: string[];
+    };
+    pg_enum: {
+        oid: string;
+        enumtypid: string;
+        enumsortorder: number;
+        enumlabel: string;
+    };
+    pg_index: {
+        indexrelid: string;
+        indrelid: string;
+        indisready: boolean;
+        indexprs: string | null;
+        indpred: string | null;
+        indkey: number[];
+        indisprimary: boolean;
+        indisunique: boolean;
+    };
+    pg_indexes: {
+        schemaname: string;
+        tablename: string;
+        indexname: string;
+        tablespace: string | null;
+        indexrelid: string;
+        indexdef: string;
+    };
+    pg_namespace: {
+        oid: number;
+        nspname: string;
+        nspowner: number;
+        nspacl: string[];
+    };
+    pg_type: {
+        oid: string;
+        typname: string;
+        typnamespace: string;
+        typowner: string;
+        typtype: string;
+        typcategory: string;
+        typarray: string;
+    };
+    pg_depend: {
+        objid: string;
+        deptype: string;
+    };
+    pg_proc: {
+        oid: string;
+        proname: string;
+        pronamespace: string;
+        prokind: string;
+    };
+    pg_settings: {
+        name: string;
+        setting: string;
+        unit: string | null;
+        category: string;
+        short_desc: string | null;
+        extra_desc: string | null;
+        context: string;
+        vartype: string;
+        source: string;
+        min_val: string | null;
+        max_val: string | null;
+        enumvals: string[] | null;
+        boot_val: string | null;
+        reset_val: string | null;
+        sourcefile: string | null;
+        sourceline: number | null;
+        pending_restart: PostgresYesOrNo;
+    };
+    'information_schema.tables': {
+        table_catalog: string;
+        table_schema: string;
+        table_name: string;
+        table_type: 'VIEW' | 'BASE TABLE' | string;
+        is_insertable_info: PostgresYesOrNo;
+        is_typed: PostgresYesOrNo;
+        commit_action: string | null;
+    };
+    'information_schema.columns': {
+        table_catalog: string;
+        table_schema: string;
+        table_name: string;
+        column_name: string;
+        ordinal_position: number;
+        column_default: string | null;
+        is_nullable: PostgresYesOrNo;
+        data_type: string;
+        dtd_identifier: string;
+        character_maximum_length: number | null;
+        character_octet_length: number | null;
+        numeric_precision: number | null;
+        numeric_precision_radix: number | null;
+        numeric_scale: number | null;
+        datetime_precision: number | null;
+        interval_type: string | null;
+        interval_precision: number | null;
+        udt_catalog: string;
+        udt_schema: string;
+        udt_name: string;
+        maximum_cardinality: number | null;
+        is_updatable: PostgresYesOrNo;
+    };
+    'information_schema.element_types': {
+        object_catalog: string;
+        object_schema: string;
+        object_name: string;
+        object_type: string;
+        collection_type_identifier: string;
+        data_type: string;
+    };
+    'information_schema.routines': {
+        specific_catalog: string;
+        specific_schema: string;
+        specific_name: string;
+        routine_catalog: string;
+        routine_schema: string;
+        routine_name: string;
+        routine_type: string;
+        data_type: string;
+        type_udt_catalog: string;
+        type_udt_schema: string;
+        type_udt_name: string;
+        dtd_identifier: string;
+        routine_body: string;
+        routine_definition: string;
+        external_name: string;
+        external_language: string;
+        is_deterministic: PostgresYesOrNo;
+        security_type: string;
+    };
+};
+
+declare type PostgresYesOrNo = 'YES' | 'NO';
+
+export declare const PrimaryColumn: (options?: Omit<ColumnOptions, "primary">) => PropertyDecorator;
+
+export declare const PrimaryGeneratedColumn: (options?: Omit<GenerateColumnOptions, "primary">) => PropertyDecorator;
+
+export declare type Processor = (ctx: ProcessorContext, items: RegisterItem[]) => void;
+
+declare class ProcessorContext extends BaseContext {
+    options: SchemaFromCodeOptions;
+    constructor(options: SchemaFromCodeOptions);
+    classToTable: WeakMap<Function, DatabaseTable>;
+    tableToMetadata: WeakMap<DatabaseTable, TableMetadata>;
+    getTableByObject(object: Function): DatabaseTable | undefined;
+    getTableMetadata(table: DatabaseTable): TableMetadata;
+    addTable(table: DatabaseTable, options: TableOptions, object: Function): void;
+    getColumnByObjectAndPropertyName(object: object, propertyName: string | symbol): {
+        table?: DatabaseTable;
+        column?: DatabaseColumn;
+    };
+    addColumn(table: DatabaseTable, column: DatabaseColumn, options: ColumnOptions, propertyName: string | symbol): void;
+    warnMissingTable(context: string, object: object, propertyName?: symbol | string): void;
+    warnMissingColumn(context: string, object: object, propertyName?: symbol | string): void;
+}
+
+declare type PropertyBased<T> = {
+    object: object;
+    propertyName: string | symbol;
+} & T;
+
+export declare type Reader = (ctx: ReaderContext, db: DatabaseClient) => Promise<void>;
+
+declare class ReaderContext extends BaseContext {
+    options: SchemaFromDatabaseOptions;
+    constructor(options: SchemaFromDatabaseOptions);
+}
+
+export declare enum Reason {
+    MissingInSource = "missing in source",
+    MissingInTarget = "missing in target",
+    Rename = "name has changed"
+}
+
+export declare const registerEnum: (options: EnumOptions) => DatabaseEnum;
+
+export declare const registerFunction: (options: FunctionOptions) => DatabaseFunction;
+
+declare type RegisterItem = {
+    type: 'database';
+    item: ClassBased<{
+        options: DatabaseOptions;
+    }>;
+} | {
+    type: 'table';
+    item: ClassBased<{
+        options: TableOptions;
+    }>;
+} | {
+    type: 'index';
+    item: ClassBased<{
+        options: IndexOptions;
+    }>;
+} | {
+    type: 'uniqueConstraint';
+    item: ClassBased<{
+        options: UniqueOptions;
+    }>;
+} | {
+    type: 'checkConstraint';
+    item: ClassBased<{
+        options: CheckOptions;
+    }>;
+} | {
+    type: 'column';
+    item: PropertyBased<{
+        options: ColumnOptions;
+    }>;
+} | {
+    type: 'function';
+    item: DatabaseFunction;
+} | {
+    type: 'enum';
+    item: DatabaseEnum;
+} | {
+    type: 'trigger';
+    item: ClassBased<{
+        options: TriggerOptions;
+    }>;
+} | {
+    type: 'extension';
+    item: ClassBased<{
+        options: ExtensionOptions;
+    }>;
+} | {
+    type: 'configurationParameter';
+    item: ClassBased<{
+        options: ConfigurationParameterOptions;
+    }>;
+} | {
+    type: 'foreignKeyColumn';
+    item: PropertyBased<{
+        options: ForeignKeyColumnOptions;
+        target: () => Function;
+    }>;
+} | {
+    type: 'foreignKeyConstraint';
+    item: ClassBased<{
+        options: ForeignKeyConstraintOptions;
+    }>;
+};
+
+export declare type SchemaDiff = {
+    reason: string;
+} & ({
+    type: 'ExtensionCreate';
+    extension: DatabaseExtension;
+} | {
+    type: 'ExtensionDrop';
+    extensionName: string;
+} | {
+    type: 'FunctionCreate';
+    function: DatabaseFunction;
+} | {
+    type: 'FunctionDrop';
+    functionName: string;
+} | {
+    type: 'TableCreate';
+    table: DatabaseTable;
+} | {
+    type: 'TableDrop';
+    tableName: string;
+} | {
+    type: 'ColumnAdd';
+    column: DatabaseColumn;
+} | {
+    type: 'ColumnRename';
+    tableName: string;
+    oldName: string;
+    newName: string;
+} | {
+    type: 'ColumnAlter';
+    tableName: string;
+    columnName: string;
+    changes: ColumnChanges;
+} | {
+    type: 'ColumnDrop';
+    tableName: string;
+    columnName: string;
+} | {
+    type: 'ConstraintAdd';
+    constraint: DatabaseConstraint;
+} | {
+    type: 'ConstraintRename';
+    tableName: string;
+    oldName: string;
+    newName: string;
+} | {
+    type: 'ConstraintDrop';
+    tableName: string;
+    constraintName: string;
+} | {
+    type: 'IndexCreate';
+    index: DatabaseIndex;
+} | {
+    type: 'IndexRename';
+    tableName: string;
+    oldName: string;
+    newName: string;
+} | {
+    type: 'IndexDrop';
+    indexName: string;
+} | {
+    type: 'TriggerCreate';
+    trigger: DatabaseTrigger;
+} | {
+    type: 'TriggerDrop';
+    tableName: string;
+    triggerName: string;
+} | {
+    type: 'ParameterSet';
+    parameter: DatabaseParameter;
+} | {
+    type: 'ParameterReset';
+    databaseName: string;
+    parameterName: string;
+} | {
+    type: 'EnumCreate';
+    enum: DatabaseEnum;
+} | {
+    type: 'EnumDrop';
+    enumName: string;
+} | {
+    type: 'OverrideCreate';
+    override: DatabaseOverride;
+} | {
+    type: 'OverrideUpdate';
+    override: DatabaseOverride;
+} | {
+    type: 'OverrideDrop';
+    overrideName: string;
+});
+
+/**
+ * Compute the difference between two database schemas
+ */
+export declare const schemaDiff: (source: DatabaseSchema, target: DatabaseSchema, options?: SchemaDiffOptions) => {
+    items: SchemaDiff[];
+    asSql: (options?: SchemaDiffToSqlOptions) => string[];
+    asHuman: () => string[];
+};
+
+export declare type SchemaDiffOptions = BaseContextOptions & {
+    tables?: IgnoreOptions;
+    columns?: IgnoreOptions;
+    indexes?: IgnoreOptions;
+    triggers?: IgnoreOptions;
+    constraints?: IgnoreOptions;
+    functions?: IgnoreOptions;
+    enums?: IgnoreOptions;
+    extensions?: IgnoreOptions;
+    parameters?: IgnoreOptions;
+    overrides?: IgnoreOptions;
+};
+
+/**
+ * Convert schema diffs into SQL statements
+ */
+export declare const schemaDiffToSql: (items: SchemaDiff[], options?: SchemaDiffToSqlOptions) => string[];
+
+export declare type SchemaDiffToSqlOptions = BaseContextOptions & {
+    comments?: boolean;
+};
+
+/**
+ * Load schema from code (decorators, etc)
+ */
+export declare const schemaFromCode: (options?: SchemaFromCodeOptions) => DatabaseSchema;
+
+export declare type SchemaFromCodeOptions = BaseContextOptions & {
+    /** automatically create indexes on foreign key columns */
+    createForeignKeyIndexes?: boolean;
+    reset?: boolean;
+    functions?: boolean;
+    extensions?: boolean;
+    parameters?: boolean;
+    overrides?: boolean;
+};
+
+/**
+ * Load schema from a database url
+ */
+export declare const schemaFromDatabase: (database: DatabaseLike, options?: SchemaFromDatabaseOptions) => Promise<DatabaseSchema>;
+
+export declare type SchemaFromDatabaseOptions = BaseContextOptions;
+
+/** Table comments here */
+export declare const Table: (options?: string | TableOptions) => ClassDecorator;
+
+declare type TableMetadata = {
+    options: TableOptions;
+    object: Function;
+    methodToColumn: Map<string | symbol, DatabaseColumn>;
+};
+
+export declare type TableOptions = {
+    name?: string;
+    primaryConstraintName?: string;
+    synchronize?: boolean;
+};
+
+export declare type Timestamp = ColumnType_2<Date, Date | string, Date | string>;
+
+export declare const Trigger: (options: TriggerOptions) => ClassDecorator;
+
+export declare type TriggerAction = 'insert' | 'update' | 'delete' | 'truncate';
+
+export declare const TriggerFunction: (options: TriggerFunctionOptions) => ClassDecorator;
+
+export declare type TriggerFunctionOptions = Omit<TriggerOptions, 'functionName'> & {
+    function: DatabaseFunction;
+};
+
+export declare type TriggerOptions = {
+    name?: string;
+    timing: TriggerTiming;
+    actions: TriggerAction[];
+    scope: TriggerScope;
+    functionName: string;
+    referencingNewTableAs?: string;
+    referencingOldTableAs?: string;
+    when?: string;
+    synchronize?: boolean;
+};
+
+export declare type TriggerScope = 'row' | 'statement';
+
+export declare type TriggerTiming = 'before' | 'after' | 'instead of';
+
+export declare const Unique: (options: UniqueOptions) => ClassDecorator;
+
+export declare type UniqueOptions = {
+    name?: string;
+    columns: string[];
+    synchronize?: boolean;
+};
+
+export declare const UpdateDateColumn: (options?: ColumnOptions) => PropertyDecorator;
+
+export { }