@contember/schema-migrations 1.4.0-rc.8 → 2.0.0-alpha.8

package/dist/types/Migration.d.ts

@@ -0,0 +1,20 @@
+import { SchemaValidatorSkippedErrors } from '@contember/schema-utils';
+export interface MigrationInfo {
+    readonly version: string;
+    readonly name: string;
+    readonly formatVersion: number;
+    readonly skippedErrors?: readonly SchemaValidatorSkippedErrors[];
+}
+interface Migration extends MigrationInfo {
+    readonly modifications: readonly Migration.Modification[];
+}
+declare namespace Migration {
+    type Modification<Data = {
+        [field: string]: any;
+    }> = {
+        modification: string;
+    } & Data;
+}
+export declare const calculateMigrationChecksum: (migration: Migration) => string;
+export type { Migration };
+//# sourceMappingURL=Migration.d.ts.map

package/dist/types/Migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Migration.d.ts","sourceRoot":"","sources":["../../src/Migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAA;AAGtE,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAA;CAChE;AAED,UAAU,SAAU,SAAQ,aAAa;IACxC,QAAQ,CAAC,aAAa,EAAE,SAAS,SAAS,CAAC,YAAY,EAAE,CAAA;CACzD;AAED,kBAAU,SAAS,CAAC;IACnB,KAAY,YAAY,CAAC,IAAI,GAAG;QAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,IAAI;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC3F;AAED,eAAO,MAAM,0BAA0B,cAAe,SAAS,KAAG,MAMjE,CAAA;AAED,YAAY,EAAE,SAAS,EAAE,CAAA"}

package/dist/types/modifications/ModificationHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModificationHandler.d.ts","sourceRoot":"","sources":["../../../src/modifications/ModificationHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAEtD,MAAM,WAAW,uBAAuB;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,mCAAmC,EAAE,8BAAwD,CAAA;AAC1G,MAAM,MAAM,8BAA8B,GAAG;IAAE,eAAe,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,mBAAmB,CAAC,IAAI;IACxC,SAAS,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,mCAAmC,GAAG,IAAI,CAAA;IAExF,gBAAgB,IAAI,aAAa,CAAA;IAEjC,QAAQ,CAAC,OAAO,EAAE,8BAA8B,GAAG,uBAAuB,CAAA;CAC1E;AAED,MAAM,WAAW,mCAAmC;IACnD,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,0BAA0B,EAAE,MAAM,IAAI,CAAA;CACtC;AAED,MAAM,WAAW,0BAA0B;IAC1C,aAAa,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,8BAA8B,CAAC,IAAI;IACnD,KAAI,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAA;CAC/F;AAED,MAAM,WAAW,MAAM,CAAC,IAAI,GAAG;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE;IACtD,UAAU,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,KAAK,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAA;CAC7F;AAGD,MAAM,WAAW,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,IAAI;IACxD,EAAE,EAAE,EAAE,CAAA;IACN,kBAAkB,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;IAChE,aAAa,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B,KAAK,mBAAmB,CAAC,IAAI,CAAC,CAAA;CAC7G;AAED,eAAO,MAAM,sBAAsB,GAAI,IAAI,EAAE,EAAE,SAAS,MAAM,mBAAmB;IAChF,EAAE,EAAE,EAAE,CAAA;IACN,OAAO,EAAE,8BAA8B,CAAC,IAAI,CAAC,CAAA;CAC7C,KAAG,gBAAgB,CAAC,EAAE,EAAE,IAAI,CAM5B,CAAA"}

package/dist/types/modifications/acl/UpdateAclSchemaModification.d.ts

@@ -0,0 +1,20 @@
+import { Acl, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateAclSchemaModificationHandler implements ModificationHandler<UpdateAclSchemaModificationData> {
+    private readonly data;
+    constructor(data: UpdateAclSchemaModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface UpdateAclSchemaModificationData {
+    schema: Acl.Schema;
+}
+export declare const updateAclSchemaModification: import("../ModificationHandler").ModificationType<"updateAclSchema", UpdateAclSchemaModificationData>;
+export declare class UpdateAclSchemaDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<import("./PatchAclSchemaModification").PatchAclSchemaModificationData>[] | import("../..").Migration.Modification<UpdateAclSchemaModificationData>[];
+}
+//# sourceMappingURL=UpdateAclSchemaModification.d.ts.map

package/dist/types/modifications/actions/CreateTargetModification.d.ts

@@ -0,0 +1,20 @@
+import { Actions, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class CreateTargetModificationHandler implements ModificationHandler<CreateTargetModificationData> {
+    private readonly data;
+    constructor(data: CreateTargetModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface CreateTargetModificationData {
+    target: Actions.AnyTarget;
+}
+export declare const createTargetModification: import("../ModificationHandler").ModificationType<"createTarget", CreateTargetModificationData>;
+export declare class CreateTargetDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateTargetModificationData>[];
+}
+//# sourceMappingURL=CreateTargetModification.d.ts.map

package/dist/types/modifications/actions/CreateTriggerModification.d.ts

@@ -0,0 +1,20 @@
+import { Actions, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class CreateTriggerModificationHandler implements ModificationHandler<CreateTriggerModificationData> {
+    private readonly data;
+    constructor(data: CreateTriggerModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface CreateTriggerModificationData {
+    trigger: Actions.AnyTrigger;
+}
+export declare const createTriggerModification: import("../ModificationHandler").ModificationType<"createTrigger", CreateTriggerModificationData>;
+export declare class CreateTriggerDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateTriggerModificationData>[];
+}
+//# sourceMappingURL=CreateTriggerModification.d.ts.map

package/dist/types/modifications/actions/RemoveTargetModification.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class RemoveTargetModificationHandler implements ModificationHandler<RemoveTargetModificationData> {
+    private readonly data;
+    constructor(data: RemoveTargetModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface RemoveTargetModificationData {
+    name: string;
+}
+export declare const removeTargetModification: import("../ModificationHandler").ModificationType<"removeTarget", RemoveTargetModificationData>;
+export declare class RemoveTargetDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<RemoveTargetModificationData>[];
+}
+//# sourceMappingURL=RemoveTargetModification.d.ts.map

package/dist/types/modifications/actions/RemoveTriggerModification.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class RemoveTriggerModificationHandler implements ModificationHandler<RemoveTriggerModificationData> {
+    private readonly data;
+    constructor(data: RemoveTriggerModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface RemoveTriggerModificationData {
+    name: string;
+}
+export declare const removeTriggerModification: import("../ModificationHandler").ModificationType<"removeTrigger", RemoveTriggerModificationData>;
+export declare class RemoveTriggerDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<RemoveTriggerModificationData>[];
+}
+//# sourceMappingURL=RemoveTriggerModification.d.ts.map

package/dist/types/modifications/actions/UpdateTargetModification.d.ts

@@ -0,0 +1,21 @@
+import { Actions, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateTargetModificationHandler implements ModificationHandler<UpdateTargetModificationData> {
+    private readonly data;
+    constructor(data: UpdateTargetModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface UpdateTargetModificationData {
+    name: string;
+    target: Actions.AnyTarget;
+}
+export declare const updateTargetModification: import("../ModificationHandler").ModificationType<"updateTarget", UpdateTargetModificationData>;
+export declare class UpdateTargetDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateTargetModificationData>[];
+}
+//# sourceMappingURL=UpdateTargetModification.d.ts.map

package/dist/types/modifications/actions/UpdateTriggerModification.d.ts

@@ -0,0 +1,20 @@
+import { Actions, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateTriggerModificationHandler implements ModificationHandler<UpdateTriggerModificationData> {
+    private readonly data;
+    constructor(data: UpdateTriggerModificationData);
+    createSql(): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface UpdateTriggerModificationData {
+    trigger: Actions.AnyTrigger;
+}
+export declare const updateTriggerModification: import("../ModificationHandler").ModificationType<"updateTrigger", UpdateTriggerModificationData>;
+export declare class UpdateTriggerDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateTriggerModificationData>[];
+}
+//# sourceMappingURL=UpdateTriggerModification.d.ts.map

package/dist/types/modifications/columns/CreateColumnModification.d.ts

@@ -0,0 +1,29 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { JSONValue, Model, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class CreateColumnModificationHandler implements ModificationHandler<CreateColumnModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: CreateColumnModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe({ createdEntities }: {
+        createdEntities: string[];
+    }): {
+        message: string;
+        failureWarning: string | undefined;
+    };
+}
+export interface CreateColumnModificationData {
+    entityName: string;
+    field: Model.AnyColumn;
+    fillValue?: JSONValue;
+    copyValue?: string;
+    valueMigrationStrategy?: 'using' | 'update';
+}
+export declare const createColumnModification: import("../ModificationHandler").ModificationType<"createColumn", CreateColumnModificationData>;
+export declare class CreateColumnDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateColumnModificationData>[];
+}
+//# sourceMappingURL=CreateColumnModification.d.ts.map

package/dist/types/modifications/columns/UpdateColumnDefinitionModification.d.ts

@@ -0,0 +1,35 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { JSONValue, Model, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateColumnDefinitionModificationHandler implements ModificationHandler<UpdateColumnDefinitionModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: UpdateColumnDefinitionModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+        failureWarning: string | undefined;
+    };
+}
+type SequenceDefinitionAlter = Model.AnyColumn['sequence'] & {
+    restart?: boolean;
+};
+type ColumnDefinitionAlter = Omit<Model.AnyColumn, 'sequence' | 'columnName' | 'name'> & {
+    sequence?: SequenceDefinitionAlter;
+};
+export interface UpdateColumnDefinitionModificationData {
+    entityName: string;
+    fieldName: string;
+    definition: ColumnDefinitionAlter;
+    fillValue?: JSONValue;
+    copyValue?: string;
+    valueMigrationStrategy?: 'using' | 'update';
+}
+export declare const updateColumnDefinitionModification: import("../ModificationHandler").ModificationType<"updateColumnDefinition", UpdateColumnDefinitionModificationData>;
+export declare class UpdateColumnDefinitionDiffer implements Differ<UpdateColumnDefinitionModificationData> {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateColumnDefinitionModificationData>[];
+}
+export {};
+//# sourceMappingURL=UpdateColumnDefinitionModification.d.ts.map

package/dist/types/modifications/columns/UpdateColumnNameModification.d.ts

@@ -0,0 +1,24 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateColumnNameModificationHandler implements ModificationHandler<UpdateColumnNameModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: UpdateColumnNameModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface UpdateColumnNameModificationData {
+    entityName: string;
+    fieldName: string;
+    columnName: string;
+}
+export declare const updateColumnNameModification: import("../ModificationHandler").ModificationType<"updateColumnName", UpdateColumnNameModificationData>;
+export declare class UpdateColumnNameDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateColumnNameModificationData>[];
+}
+//# sourceMappingURL=UpdateColumnNameModification.d.ts.map

package/dist/types/modifications/columns/columnUtils.d.ts

@@ -0,0 +1,18 @@
+import { JSONValue, Model } from '@contember/schema';
+import { MigrationBuilder } from '@contember/database-migrations';
+export declare const fillSeed: ({ builder, entity, columnName, nullable, type, seedExpression }: {
+    entity: Model.Entity;
+    columnName: string;
+    nullable: boolean;
+    builder: MigrationBuilder;
+    type: "creating" | "updating";
+    seedExpression: string;
+}) => void;
+export declare const formatSeedExpression: ({ model, entity, columnType, fillValue, copyValue }: {
+    model: Model.Schema;
+    entity: Model.Entity;
+    columnType: string;
+    fillValue?: JSONValue;
+    copyValue?: string;
+}) => string | null;
+//# sourceMappingURL=columnUtils.d.ts.map

package/dist/types/modifications/columns/columnUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnUtils.d.ts","sourceRoot":"","sources":["../../../../src/modifications/columns/columnUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAe,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAG9E,eAAO,MAAM,QAAQ,oEAAqE;IACzF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,gBAAgB,CAAA;IACzB,IAAI,EAAE,UAAU,GAAG,UAAU,CAAA;IAC7B,cAAc,EAAE,MAAM,CAAA;CACtB,SAeA,CAAA;AAGD,eAAO,MAAM,oBAAoB,wDAAyD;IACzF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAA;IACnB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,KAAG,MAAM,GAAG,IAQZ,CAAA"}

package/dist/types/modifications/constraints/CreateUniqueConstraintModification.d.ts

@@ -0,0 +1,26 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Model, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler';
+export declare class CreateUniqueConstraintModificationHandler implements ModificationHandler<CreateUniqueConstraintModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: CreateUniqueConstraintModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe({ createdEntities }: {
+        createdEntities: string[];
+    }): {
+        message: string;
+        failureWarning: string | undefined;
+    };
+}
+export declare const createUniqueConstraintModification: import("../ModificationHandler").ModificationType<"createUniqueConstraint", CreateUniqueConstraintModificationData>;
+export interface CreateUniqueConstraintModificationData {
+    entityName: string;
+    unique: Model.UniqueConstraint;
+}
+export declare class CreateUniqueConstraintDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateUniqueConstraintModificationData>[];
+}
+//# sourceMappingURL=CreateUniqueConstraintModification.d.ts.map

package/dist/types/modifications/constraints/RemoveUniqueConstraintModification.d.ts

@@ -0,0 +1,29 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler';
+export declare class RemoveUniqueConstraintModificationHandler implements ModificationHandler<RemoveUniqueConstraintModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: RemoveUniqueConstraintModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+    getFields(): readonly string[];
+}
+export declare const removeUniqueConstraintModification: import("../ModificationHandler").ModificationType<"removeUniqueConstraint", RemoveUniqueConstraintModificationData>;
+export type RemoveUniqueConstraintModificationData = {
+    entityName: string;
+    constraintName: string;
+    fields?: never;
+} | {
+    entityName: string;
+    fields: readonly string[];
+    constraintName?: never;
+};
+export declare class RemoveUniqueConstraintDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<RemoveUniqueConstraintModificationData>[];
+}
+//# sourceMappingURL=RemoveUniqueConstraintModification.d.ts.map

package/dist/types/modifications/constraints/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/modifications/constraints/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC,eAAO,MAAM,0BAA0B,8BAA+B;IACrE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;IACzB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAA;IACnB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;CACpB,aA4BA,CAAA"}

package/dist/types/modifications/differs/RemoveChangedFieldDiffer.d.ts

@@ -0,0 +1,8 @@
+import { Differ } from '../ModificationHandler';
+import { Model, Schema } from '@contember/schema';
+export declare class RemoveChangedFieldDiffer implements Differ {
+    private readonly matcher;
+    constructor(matcher: (originalField: Model.AnyField) => boolean);
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<import("../fields").RemoveFieldModificationData>[];
+}
+//# sourceMappingURL=RemoveChangedFieldDiffer.d.ts.map

package/dist/types/modifications/differs/RemoveViewDiffer.d.ts

@@ -0,0 +1,12 @@
+import { Differ } from '../ModificationHandler';
+import { Schema } from '@contember/schema';
+/**
+ * Remove changed or removed view.
+ */
+export declare class RemoveViewDiffer implements Differ {
+    constructor();
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<{
+        [field: string]: any;
+    }>[];
+}
+//# sourceMappingURL=RemoveViewDiffer.d.ts.map

package/dist/types/modifications/entities/CreateEntityModification.d.ts

@@ -0,0 +1,24 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerCreateSqlOptions, ModificationHandlerOptions } from '../ModificationHandler';
+import { PossibleEntityShapeInMigrations } from '../../utils/PartialEntity.js';
+export declare class CreateEntityModificationHandler implements ModificationHandler<CreateEntityModificationData> {
+    private readonly data;
+    private readonly schema;
+    private readonly options;
+    constructor(data: CreateEntityModificationData, schema: Schema, options: ModificationHandlerOptions);
+    createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export declare const createEntityModification: import("../ModificationHandler").ModificationType<"createEntity", CreateEntityModificationData>;
+export declare class CreateEntityDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateEntityModificationData>[];
+}
+export interface CreateEntityModificationData {
+    entity: PossibleEntityShapeInMigrations;
+}
+//# sourceMappingURL=CreateEntityModification.d.ts.map

package/dist/types/modifications/entities/RemoveEntityModification.d.ts

@@ -0,0 +1,25 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerCreateSqlOptions, ModificationHandlerOptions } from '../ModificationHandler';
+export declare class RemoveEntityModificationHandler implements ModificationHandler<RemoveEntityModificationData> {
+    private readonly data;
+    private readonly schema;
+    private readonly options;
+    constructor(data: RemoveEntityModificationData, schema: Schema, options: ModificationHandlerOptions);
+    createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void;
+    getSchemaUpdater(): SchemaUpdater;
+    private getFieldsToRemove;
+    describe(): {
+        message: string;
+        isDestructive: boolean;
+    };
+}
+export interface RemoveEntityModificationData {
+    entityName: string;
+}
+export declare const removeEntityModification: import("../ModificationHandler").ModificationType<"removeEntity", RemoveEntityModificationData>;
+export declare class RemoveEntityDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<RemoveEntityModificationData>[];
+}
+//# sourceMappingURL=RemoveEntityModification.d.ts.map

package/dist/types/modifications/entities/ToggleEventLogModification.d.ts

@@ -0,0 +1,24 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerCreateSqlOptions, ModificationHandlerOptions } from '../ModificationHandler';
+export declare class ToggleEventLogModificationHandler implements ModificationHandler<ToggleEventLogModificationData> {
+    private readonly data;
+    private readonly schema;
+    private readonly options;
+    constructor(data: ToggleEventLogModificationData, schema: Schema, options: ModificationHandlerOptions);
+    createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface ToggleEventLogModificationData {
+    entityName: string;
+    enabled: boolean;
+}
+export declare const toggleEventLogModification: import("../ModificationHandler").ModificationType<"toggleEventLog", ToggleEventLogModificationData>;
+export declare class ToggleEventLogDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<ToggleEventLogModificationData>[];
+}
+//# sourceMappingURL=ToggleEventLogModification.d.ts.map

package/dist/types/modifications/entities/UpdateEntityOrderByModification.d.ts

@@ -0,0 +1,23 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Model, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateEntityOrderByModificationHandler implements ModificationHandler<UpdateEntityOrderByModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: UpdateEntityOrderByModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface UpdateEntityOrderByModificationData {
+    entityName: string;
+    orderBy?: readonly Model.OrderBy[];
+}
+export declare const updateEntityOrderByModification: import("../ModificationHandler").ModificationType<"updateEntityOrderBy", UpdateEntityOrderByModificationData>;
+export declare class UpdateEntityOrderByDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateEntityOrderByModificationData>[];
+}
+//# sourceMappingURL=UpdateEntityOrderByModification.d.ts.map

package/dist/types/modifications/entities/UpdateEntityTableNameModification.d.ts

@@ -0,0 +1,23 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateEntityTableNameModificationHandler implements ModificationHandler<UpdateEntityTableNameModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: UpdateEntityTableNameModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface UpdateEntityTableNameModificationData {
+    entityName: string;
+    tableName: string;
+}
+export declare const updateEntityTableNameModification: import("../ModificationHandler").ModificationType<"updateEntityTableName", UpdateEntityTableNameModificationData>;
+export declare class UpdateEntityTableNameDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateEntityTableNameModificationData>[];
+}
+//# sourceMappingURL=UpdateEntityTableNameModification.d.ts.map

package/dist/types/modifications/enums/CreateEnumModification.d.ts

@@ -0,0 +1,23 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class CreateEnumModificationHandler implements ModificationHandler<CreateEnumModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: CreateEnumModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface CreateEnumModificationData {
+    enumName: string;
+    values: readonly string[];
+}
+export declare const createEnumModification: import("../ModificationHandler").ModificationType<"createEnum", CreateEnumModificationData>;
+export declare class CreateEnumDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateEnumModificationData>[];
+}
+//# sourceMappingURL=CreateEnumModification.d.ts.map

package/dist/types/modifications/enums/RemoveEnumModification.d.ts

@@ -0,0 +1,22 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class RemoveEnumModificationHandler implements ModificationHandler<RemoveEnumModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: RemoveEnumModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export interface RemoveEnumModificationData {
+    enumName: string;
+}
+export declare const removeEnumModification: import("../ModificationHandler").ModificationType<"removeEnum", RemoveEnumModificationData>;
+export declare class RemoveEnumDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<RemoveEnumModificationData>[];
+}
+//# sourceMappingURL=RemoveEnumModification.d.ts.map

package/dist/types/modifications/enums/UpdateEnumModification.d.ts

@@ -0,0 +1,24 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler } from '../ModificationHandler';
+export declare class UpdateEnumModificationHandler implements ModificationHandler<UpdateEnumModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: UpdateEnumModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+        failureWarning: string | undefined;
+    };
+}
+export interface UpdateEnumModificationData {
+    enumName: string;
+    values: readonly string[];
+}
+export declare const updateEnumModification: import("../ModificationHandler").ModificationType<"updateEnum", UpdateEnumModificationData>;
+export declare class UpdateEnumDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<UpdateEnumModificationData>[];
+}
+//# sourceMappingURL=UpdateEnumModification.d.ts.map

package/dist/types/modifications/fields/RemoveFieldModification.d.ts

@@ -0,0 +1,25 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler';
+export declare class RemoveFieldModificationHandler implements ModificationHandler<RemoveFieldModificationData> {
+    private readonly data;
+    private readonly schema;
+    private readonly options;
+    constructor(data: RemoveFieldModificationData, schema: Schema, options: ModificationHandlerOptions);
+    createSql(builder: MigrationBuilder): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+        isDestructive: boolean;
+    };
+}
+export interface RemoveFieldModificationData {
+    entityName: string;
+    fieldName: string;
+}
+export declare const removeFieldModification: import("../ModificationHandler").ModificationType<"removeField", RemoveFieldModificationData>;
+export declare class RemoveFieldDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<RemoveFieldModificationData>[];
+}
+//# sourceMappingURL=RemoveFieldModification.d.ts.map

package/dist/types/modifications/indexes/CreateIndexModification.d.ts

@@ -0,0 +1,23 @@
+import { MigrationBuilder } from '@contember/database-migrations';
+import { Model, Schema } from '@contember/schema';
+import { SchemaUpdater } from '../utils/schemaUpdateUtils';
+import { Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler';
+export declare class CreateIndexModificationHandler implements ModificationHandler<CreateIndexModificationData> {
+    private readonly data;
+    private readonly schema;
+    constructor(data: CreateIndexModificationData, schema: Schema);
+    createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): void;
+    getSchemaUpdater(): SchemaUpdater;
+    describe(): {
+        message: string;
+    };
+}
+export declare const createIndexModification: import("../ModificationHandler").ModificationType<"createIndex", CreateIndexModificationData>;
+export interface CreateIndexModificationData {
+    entityName: string;
+    index: Model.Index;
+}
+export declare class CreateIndexDiffer implements Differ {
+    createDiff(originalSchema: Schema, updatedSchema: Schema): import("../..").Migration.Modification<CreateIndexModificationData>[];
+}
+//# sourceMappingURL=CreateIndexModification.d.ts.map