@contember/schema-utils 2.1.0-alpha.36 → 2.1.0-alpha.39

package/dist/types/acl/PredicateDefinitionProcessor.d.ts

@@ -0,0 +1,32 @@
+import { Acl, Input, Model } from '@contember/schema';
+declare class PredicateDefinitionProcessor {
+    private readonly schema;
+    constructor(schema: Model.Schema);
+    process<WhereValue, PredicateExtension = never>(entity: Model.Entity, definition: Acl.PredicateDefinition<PredicateExtension>, handler: PredicateDefinitionProcessor.Handler<WhereValue, PredicateExtension>): Input.Where<WhereValue>;
+    private processInternal;
+}
+declare namespace PredicateDefinitionProcessor {
+    interface Handler<R, T> {
+        handleColumn(ctx: {
+            value: T | Acl.PredicateVariable | Input.Condition;
+            entity: Model.Entity;
+            column: Model.AnyColumn;
+            path: string[];
+        }): R | Input.Where | Input.Condition | undefined | [string, R | Input.Where | Input.Condition];
+        handleRelation(ctx: {
+            value: T | Acl.PredicateVariable;
+            entity: Model.Entity;
+            relation: Model.Relation;
+            targetEntity: Model.Entity;
+            path: string[];
+        }): R | Input.Where | undefined | [string, R | Input.Where];
+        handleUndefinedField?(ctx: {
+            entity: Model.Entity;
+            name: string;
+            value: any;
+            path: string[];
+        }): never | undefined | R | Input.Where;
+    }
+}
+export { PredicateDefinitionProcessor };
+//# sourceMappingURL=PredicateDefinitionProcessor.d.ts.map

package/dist/types/acl/PredicateDefinitionProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PredicateDefinitionProcessor.d.ts","sourceRoot":"","sources":["../../../src/acl/PredicateDefinitionProcessor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAY,MAAM,mBAAmB,CAAA;AAE/D,cAAM,4BAA4B;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK,CAAC,MAAM;IAE1C,OAAO,CAAC,UAAU,EAAE,kBAAkB,GAAG,KAAK,EACpD,MAAM,EAAE,KAAK,CAAC,MAAM,EACpB,UAAU,EAAE,GAAG,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,EACvD,OAAO,EAAE,4BAA4B,CAAC,OAAO,CAAC,UAAU,EAAE,kBAAkB,CAAC,GAC3E,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC;IAI1B,OAAO,CAAC,eAAe;CAqEvB;AAED,kBAAU,4BAA4B,CAAC;IACtC,UAAiB,OAAO,CAAC,CAAC,EAAE,CAAC;QAC5B,YAAY,CAAC,GAAG,EAAE;YACjB,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAA;YAClD,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;YACpB,MAAM,EAAE,KAAK,CAAC,SAAS,CAAA;YACvB,IAAI,EAAE,MAAM,EAAE,CAAA;SACd,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,GAAG,SAAS,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAA;QAE/F,cAAc,CAAC,GAAG,EAAE;YACnB,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,iBAAiB,CAAA;YAChC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;YACpB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAA;YACxB,YAAY,EAAE,KAAK,CAAC,MAAM,CAAA;YAC1B,IAAI,EAAE,MAAM,EAAE,CAAA;SACd,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,GAAG,SAAS,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;QAE3D,oBAAoB,CAAC,CAAC,GAAG,EAAE;YAC1B,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;YACpB,IAAI,EAAE,MAAM,CAAA;YACZ,KAAK,EAAE,GAAG,CAAA;YACV,IAAI,EAAE,MAAM,EAAE,CAAA;SACd,GAAG,KAAK,GAAG,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAA;KACvC;CACD;AAED,OAAO,EAAE,4BAA4B,EAAE,CAAA"}

package/dist/types/acl/index.d.ts

@@ -0,0 +1,4 @@
+export * from './AllowAllPermissionFactory';
+export * from './PredicateDefinitionProcessor';
+export * from './schemaUtils';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/acl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/acl/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,eAAe,CAAA"}

package/dist/types/acl/schemaUtils.d.ts

@@ -0,0 +1,3 @@
+import { Acl } from '@contember/schema';
+export declare const getRoleVariables: (roleName: string, schema: Acl.Schema) => Acl.Variables;
+//# sourceMappingURL=schemaUtils.d.ts.map

package/dist/types/acl/schemaUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaUtils.d.ts","sourceRoot":"","sources":["../../../src/acl/schemaUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AAEvC,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,EAAE,QAAQ,GAAG,CAAC,MAAM,KAAG,GAAG,CAAC,SAM3E,CAAA"}

package/dist/types/dataUtils.d.ts

@@ -0,0 +1,18 @@
+import { Input, Model, Value } from '@contember/schema';
+export interface Providers {
+    uuid: (args?: {
+        version?: 4 | 7;
+    }) => string;
+    now: () => Date;
+}
+export declare const resolveDefaultValue: (column: Model.AnyColumn, providers: Pick<Providers, "now">) => import("@contember/schema").JSONValue | undefined;
+export declare const resolveColumnValue: ({ entity, column, input, }: {
+    entity: Model.Entity;
+    column: Model.AnyColumn;
+    input: Input.ColumnValue | undefined;
+}, providers: Providers, options: {
+    uuidVersion?: 4 | 7;
+}) => Value.FieldValue | undefined;
+export declare class NoDataError extends Error {
+}
+//# sourceMappingURL=dataUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataUtils.d.ts","sourceRoot":"","sources":["../../src/dataUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEvD,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;KAAE,KAAK,MAAM,CAAA;IAC5C,GAAG,EAAE,MAAM,IAAI,CAAA;CACf;AAED,eAAO,MAAM,mBAAmB,GAAI,QAAQ,KAAK,CAAC,SAAS,EAAE,WAAW,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,sDAuC7F,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC9B,4BAIG;IACF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAA;IACpB,MAAM,EAAE,KAAK,CAAC,SAAS,CAAA;IACvB,KAAK,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAA;CACpC,EACD,WAAW,SAAS,EACpB,SAAS;IACR,WAAW,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;CACnB,KACC,KAAK,CAAC,UAAU,GAAG,SAYrB,CAAA;AAED,qBAAa,WAAY,SAAQ,KAAK;CAAG"}

package/dist/types/definition-generator/AclDefinitionCodeGenerator.d.ts

@@ -0,0 +1,19 @@
+import { Acl, Model, Schema } from '@contember/schema';
+import { DefinitionNamingConventions } from './DefinitionNamingConventions';
+export declare class AclDefinitionCodeGenerator {
+    private readonly definitionNamingConventions;
+    constructor(definitionNamingConventions?: DefinitionNamingConventions);
+    generateRoles({ acl }: {
+        acl: Acl.Schema;
+    }): string;
+    private generateRole;
+    generateAclVariables({ acl }: {
+        acl: Acl.Schema;
+    }): string;
+    generateEntityAcl({ entity, schema }: {
+        entity: Model.Entity;
+        schema: Schema;
+    }): string;
+    private getMatchingOperations;
+}
+//# sourceMappingURL=AclDefinitionCodeGenerator.d.ts.map

package/dist/types/definition-generator/AclDefinitionCodeGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AclDefinitionCodeGenerator.d.ts","sourceRoot":"","sources":["../../../src/definition-generator/AclDefinitionCodeGenerator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAI3E,qBAAa,0BAA0B;IAErC,OAAO,CAAC,QAAQ,CAAC,2BAA2B;gBAA3B,2BAA2B,8BAAoC;IAI1E,aAAa,CAAC,EAAE,GAAG,EAAE,EAAE;QAAE,GAAG,EAAE,GAAG,CAAC,MAAM,CAAA;KAAE,GAAG,MAAM;IAS1D,OAAO,CAAC,YAAY;IAMb,oBAAoB,CAAC,EAAE,GAAG,EAAE,EAAE;QAAE,GAAG,EAAE,GAAG,CAAC,MAAM,CAAA;KAAE,GAAG,MAAM;IA0B1D,iBAAiB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAiD9F,OAAO,CAAC,qBAAqB;CAqB7B"}

package/dist/types/definition-generator/DefinitionCodeGenerator.d.ts

@@ -0,0 +1,27 @@
+import { Model, Schema } from '@contember/schema';
+import { NamingConventions } from '../model';
+import { DefinitionNamingConventions } from './DefinitionNamingConventions';
+import { AclDefinitionCodeGenerator } from './AclDefinitionCodeGenerator';
+export declare class DefinitionCodeGenerator {
+    private readonly schemaNamingConventions;
+    private readonly definitionNamingConventions;
+    private readonly aclGenerator;
+    constructor(schemaNamingConventions?: NamingConventions, definitionNamingConventions?: DefinitionNamingConventions, aclGenerator?: AclDefinitionCodeGenerator);
+    generate(schema: Schema): string;
+    private generateEnum;
+    generateEntity({ entity, schema }: {
+        entity: Model.Entity;
+        schema: Schema;
+    }): string;
+    private generateUniqueConstraint;
+    private generateIndex;
+    private generateView;
+    generateField({ entity, field, schema }: {
+        entity: Model.Entity;
+        field: Model.AnyField;
+        schema: Schema;
+    }): string | undefined;
+    private generateColumn;
+    private formatIdentifier;
+}
+//# sourceMappingURL=DefinitionCodeGenerator.d.ts.map

package/dist/types/definition-generator/DefinitionCodeGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefinitionCodeGenerator.d.ts","sourceRoot":"","sources":["../../../src/definition-generator/DefinitionCodeGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAY,MAAM,mBAAmB,CAAA;AAC3D,OAAO,EAAmE,iBAAiB,EAA4B,MAAM,UAAU,CAAA;AAEvI,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAEzE,qBAAa,uBAAuB;IAElC,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,2BAA2B;IAC5C,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAFZ,uBAAuB,GAAE,iBAAkD,EAC3E,2BAA2B,8BAAoC,EAC/D,YAAY,6BAAmC;IAI1D,QAAQ,CAAC,MAAM,EAAE,MAAM;IAS9B,OAAO,CAAC,YAAY;IAIb,cAAc,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAa3F,OAAO,CAAC,wBAAwB;IAMhC,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,YAAY;IAYb,aAAa,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,GAAG,SAAS;IA4HpI,OAAO,CAAC,cAAc;IA+BtB,OAAO,CAAC,gBAAgB;CAGxB"}

package/dist/types/definition-generator/DefinitionNamingConventions.d.ts

@@ -0,0 +1,7 @@
+export declare class DefinitionNamingConventions {
+    private static reservedWords;
+    formatIdentifier(id: string): string;
+    roleVarName(id: string): string;
+    variableVarName(role: string, id: string): string;
+}
+//# sourceMappingURL=DefinitionNamingConventions.d.ts.map

package/dist/types/definition-generator/DefinitionNamingConventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefinitionNamingConventions.d.ts","sourceRoot":"","sources":["../../../src/definition-generator/DefinitionNamingConventions.ts"],"names":[],"mappings":"AAAA,qBAAa,2BAA2B;IACvC,OAAO,CAAC,MAAM,CAAC,aAAa,CAiD1B;IAEK,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAKpC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAI/B,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;CAGxD"}

package/dist/types/definition-generator/TsDefinitionGenerator.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from '@contember/schema';
+import { NamingConventions } from '../model';
+/**
+ * @deprecated use {@link DefinitionCodeGenerator}
+ */
+export declare class TsDefinitionGenerator {
+    private readonly schema;
+    private readonly conventions;
+    constructor(schema: Schema, conventions?: NamingConventions);
+    generate(): string;
+}
+//# sourceMappingURL=TsDefinitionGenerator.d.ts.map

package/dist/types/definition-generator/TsDefinitionGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TsDefinitionGenerator.d.ts","sourceRoot":"","sources":["../../../src/definition-generator/TsDefinitionGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAA4B,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAGtE;;GAEG;AACH,qBAAa,qBAAqB;IAEhC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBADX,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,iBAAkD;IAI1E,QAAQ;CAIf"}

package/dist/types/definition-generator/index.d.ts

@@ -0,0 +1,5 @@
+export * from './TsDefinitionGenerator';
+export * from './AclDefinitionCodeGenerator';
+export * from './DefinitionCodeGenerator';
+export * from './DefinitionNamingConventions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/definition-generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/definition-generator/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,2BAA2B,CAAA;AACzC,cAAc,+BAA+B,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from '@contember/schema';
+import * as Typesafe from '@contember/typesafe';
+export * from './definition-generator';
+export * from './lax';
+export * from './model';
+export * from './acl';
+export * from './dataUtils';
+export * from './validation';
+export * from './schemaNormalizer';
+export * from './schemaFilter';
+export * from './schemaChecksum';
+export { compareArraysIgnoreOrder, deepCompare } from './utils';
+export declare const emptySchema: Schema;
+export declare const schemaType: Typesafe.Type<Schema>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE1C,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAI/C,cAAc,wBAAwB,CAAA;AACtC,cAAc,OAAO,CAAA;AACrB,cAAc,SAAS,CAAA;AACvB,cAAc,OAAO,CAAA;AACrB,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,kBAAkB,CAAA;AAChC,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE/D,eAAO,MAAM,WAAW,EAAE,MAMzB,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,CAM3C,CAAA"}

package/dist/types/lax/LaxSchemaConverter.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from '@contember/schema';
+import { LaxSchema } from './schema';
+import { NamingConventions } from '../model';
+export declare class LaxSchemaConverter {
+    private readonly schema;
+    private readonly conventions;
+    constructor(schema: LaxSchema, conventions?: NamingConventions);
+    convert(): Schema;
+}
+//# sourceMappingURL=LaxSchemaConverter.d.ts.map

package/dist/types/lax/LaxSchemaConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LaxSchemaConverter.d.ts","sourceRoot":"","sources":["../../../src/lax/LaxSchemaConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAY,MAAM,mBAAmB,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAqE,MAAM,UAAU,CAAA;AACvG,OAAO,EAA4B,iBAAiB,EAA4B,MAAM,UAAU,CAAA;AAehG,qBAAa,kBAAkB;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBADX,MAAM,EAAE,SAAS,EACjB,WAAW,GAAE,iBAAkD;IAI1E,OAAO,IAAI,MAAM;CAIxB"}

package/dist/types/lax/index.d.ts

@@ -0,0 +1,3 @@
+export * from './schema';
+export { LaxSchemaConverter } from './LaxSchemaConverter';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lax/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lax/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/types/lax/schema.d.ts

@@ -0,0 +1,285 @@
+import * as Typesafe from '@contember/typesafe';
+declare const LaxSchemaField: Typesafe.Type<({
+    type: "string";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "boolean";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "date";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "manyHasOne";
+} & {
+    readonly targetEntity: string;
+    readonly targetField: string;
+} & {
+    readonly notNull?: boolean | undefined;
+}) | ({
+    type: "manyHasManyInverse";
+} & {
+    readonly targetEntity: string;
+    readonly targetField: string;
+} & {
+    readonly notNull?: boolean | undefined;
+}) | ({
+    type: "oneHasMany";
+} & {
+    readonly targetEntity: string;
+    readonly targetField: string;
+} & {
+    readonly notNull?: boolean | undefined;
+}) | ({
+    type: "oneHasOneInverse";
+} & {
+    readonly targetEntity: string;
+    readonly targetField: string;
+} & {
+    readonly notNull?: boolean | undefined;
+}) | ({
+    type: "enum";
+} & {
+    readonly values: readonly string[];
+    readonly enumName: string;
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "oneHasOne";
+} & {
+    readonly targetEntity: string;
+    readonly targetField: string;
+} & {
+    readonly notNull?: boolean | undefined;
+}) | ({
+    type: "manyHasMany";
+} & {
+    readonly targetEntity: string;
+    readonly targetField: string;
+} & {
+    readonly notNull?: boolean | undefined;
+}) | ({
+    type: "int";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "float";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "json";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+}) | ({
+    type: "datetime";
+} & {
+    readonly notNull?: boolean | undefined;
+    readonly unique?: boolean | undefined;
+})>;
+export type LaxSchemaField = ReturnType<typeof LaxSchemaField>;
+export type LaxSchemaEnum = Extract<LaxSchemaField, {
+    type: 'enum';
+}>;
+export type LaxSchemaColumn = Extract<LaxSchemaField, {
+    type: 'int' | 'float' | 'boolean' | 'string' | 'json' | 'datetime' | 'date' | 'uuid';
+}>;
+export type LaxSchemaRelation = Extract<LaxSchemaField, {
+    type: 'oneHasOne' | 'oneHasOneInverse' | 'manyHasMany' | 'manyHasManyInverse' | 'oneHasMany' | 'manyHasOne';
+}>;
+declare const LaxSchemaEntity: Typesafe.Type<{
+    readonly fields: {
+        readonly [x: string]: ({
+            type: "string";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "boolean";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "date";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "manyHasOne";
+        } & {
+            readonly targetEntity: string;
+            readonly targetField: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+        }) | ({
+            type: "manyHasManyInverse";
+        } & {
+            readonly targetEntity: string;
+            readonly targetField: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+        }) | ({
+            type: "oneHasMany";
+        } & {
+            readonly targetEntity: string;
+            readonly targetField: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+        }) | ({
+            type: "oneHasOneInverse";
+        } & {
+            readonly targetEntity: string;
+            readonly targetField: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+        }) | ({
+            type: "enum";
+        } & {
+            readonly values: readonly string[];
+            readonly enumName: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "oneHasOne";
+        } & {
+            readonly targetEntity: string;
+            readonly targetField: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+        }) | ({
+            type: "manyHasMany";
+        } & {
+            readonly targetEntity: string;
+            readonly targetField: string;
+        } & {
+            readonly notNull?: boolean | undefined;
+        }) | ({
+            type: "int";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "float";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "json";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        }) | ({
+            type: "datetime";
+        } & {
+            readonly notNull?: boolean | undefined;
+            readonly unique?: boolean | undefined;
+        });
+    };
+}>;
+export type LaxSchemaEntity = ReturnType<typeof LaxSchemaEntity>;
+export declare const LaxSchema: Typesafe.Type<{
+    readonly entities: {
+        readonly [x: string]: {
+            readonly fields: {
+                readonly [x: string]: ({
+                    type: "string";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "boolean";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "date";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "manyHasOne";
+                } & {
+                    readonly targetEntity: string;
+                    readonly targetField: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                }) | ({
+                    type: "manyHasManyInverse";
+                } & {
+                    readonly targetEntity: string;
+                    readonly targetField: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                }) | ({
+                    type: "oneHasMany";
+                } & {
+                    readonly targetEntity: string;
+                    readonly targetField: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                }) | ({
+                    type: "oneHasOneInverse";
+                } & {
+                    readonly targetEntity: string;
+                    readonly targetField: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                }) | ({
+                    type: "enum";
+                } & {
+                    readonly values: readonly string[];
+                    readonly enumName: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "oneHasOne";
+                } & {
+                    readonly targetEntity: string;
+                    readonly targetField: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                }) | ({
+                    type: "manyHasMany";
+                } & {
+                    readonly targetEntity: string;
+                    readonly targetField: string;
+                } & {
+                    readonly notNull?: boolean | undefined;
+                }) | ({
+                    type: "int";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "float";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "json";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                }) | ({
+                    type: "datetime";
+                } & {
+                    readonly notNull?: boolean | undefined;
+                    readonly unique?: boolean | undefined;
+                });
+            };
+        };
+    };
+}>;
+export type LaxSchema = ReturnType<typeof LaxSchema>;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/types/lax/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/lax/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AA4B/C,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAelB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAA;AAC9D,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC,CAAA;AAC/I,MAAM,MAAM,iBAAiB,GAAG,OAAO,CACtC,cAAc,EACd;IAAE,IAAI,EAAE,WAAW,GAAG,kBAAkB,GAAG,aAAa,GAAG,oBAAoB,GAAG,YAAY,GAAG,YAAY,CAAA;CAAE,CAC/G,CAAA;AAED,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;AAEhE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/types/model/NamingConventions.d.ts

@@ -0,0 +1,17 @@
+export interface NamingConventions {
+    getPrimaryField(): string;
+    getColumnName(fieldName: string): string;
+    getTableName(entityName: string): string;
+    getJoiningColumnName(relationName: string): string;
+    getJoiningTableName(entity: string, relation: string): string;
+    getJoiningTableColumnNames(owningEntity: string, owningRelation: string, inverseEntity: string, inverseRelation?: string): [string, string];
+}
+export declare class DefaultNamingConventions implements NamingConventions {
+    getPrimaryField(): string;
+    getColumnName(fieldName: string): string;
+    getTableName(entityName: string): string;
+    getJoiningColumnName(relationName: string): string;
+    getJoiningTableName(entity: string, relation: string): string;
+    getJoiningTableColumnNames(owningEntity: string, owningRelation: string, inverseEntity: string, inverseRelation?: string): [string, string];
+}
+//# sourceMappingURL=NamingConventions.d.ts.map

package/dist/types/model/NamingConventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NamingConventions.d.ts","sourceRoot":"","sources":["../../../src/model/NamingConventions.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IACjC,eAAe,IAAI,MAAM,CAAA;IAEzB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;IAExC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;IAExC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAA;IAElD,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;IAE7D,0BAA0B,CACzB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,eAAe,CAAC,EAAE,MAAM,GACtB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnB;AAGD,qBAAa,wBAAyB,YAAW,iBAAiB;IACjE,eAAe,IAAI,MAAM;IAIzB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIxC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIxC,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAIlD,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI7D,0BAA0B,CACzB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,eAAe,CAAC,EAAE,MAAM,GACtB,CAAC,MAAM,EAAE,MAAM,CAAC;CAMnB"}

package/dist/types/model/index.d.ts

@@ -0,0 +1,4 @@
+export * from './modelUtils';
+export * from './resolveDefaultColumnType';
+export * from './NamingConventions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/model/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/model/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA"}

package/dist/types/model/modelUtils.d.ts

@@ -0,0 +1,28 @@
+import { Model } from '@contember/schema';
+export declare enum ModelErrorCode {
+    ENTITY_NOT_FOUND = "entityNotFound",
+    FIELD_NOT_FOUND = "fieldNotFound",
+    NOT_RELATION = "notRelation",
+    NOT_OWNING_SIDE = "notOwningSide"
+}
+export declare class ModelError extends Error {
+    readonly code: ModelErrorCode;
+    constructor(code: ModelErrorCode, message: string);
+}
+export declare const getEntity: (schema: Model.Schema, entityName: string) => Model.Entity;
+export declare const getField: (entity: Model.Entity, fieldName: string) => Model.AnyField;
+export declare const getColumnName: (schema: Model.Schema, entity: Model.Entity, fieldName: string) => string;
+export declare const tryGetColumnName: (schema: Model.Schema, entity: Model.Entity, fieldName: string) => string | undefined;
+export declare const getColumnType: (schema: Model.Schema, entity: Model.Entity, fieldName: string) => string;
+export declare const getTargetEntity: (schema: Model.Schema, entity: Model.Entity, relationName: string) => Model.Entity | null;
+export declare const acceptEveryFieldVisitor: <T>(schema: Model.Schema, entity: string | Model.Entity, visitor: Model.FieldVisitor<T>) => {
+    [fieldName: string]: T;
+};
+export declare const acceptFieldVisitor: <T>(schema: Model.Schema, entity: string | Model.Entity, field: string | Model.AnyField, visitor: Model.FieldVisitor<T>) => T;
+export declare const acceptRelationTypeVisitor: <T>(schema: Model.Schema, entity: string | Model.Entity, relation: string | Model.AnyRelation, visitor: Model.RelationByTypeVisitor<T>) => T;
+export declare const isRelation: (field: Model.AnyField) => field is Model.AnyRelation;
+export declare const isInverseRelation: (relation: Model.Relation) => relation is Model.InverseRelation;
+export declare const isOwningRelation: (relation: Model.Relation) => relation is Model.OwningRelation;
+export declare const isColumn: (field: Model.AnyField) => field is Model.AnyColumn;
+export declare const emptyModelSchema: Model.Schema;
+//# sourceMappingURL=modelUtils.d.ts.map

package/dist/types/model/modelUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelUtils.d.ts","sourceRoot":"","sources":["../../../src/model/modelUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEzC,oBAAY,cAAc;IACzB,gBAAgB,mBAAmB;IACnC,eAAe,kBAAkB;IACjC,YAAY,gBAAgB;IAC5B,eAAe,kBAAkB;CACjC;AAED,qBAAa,UAAW,SAAQ,KAAK;aACR,IAAI,EAAE,cAAc;gBAApB,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM;CAGjE;AAOD,eAAO,MAAM,SAAS,GAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,YAAY,MAAM,KAAG,KAAK,CAAC,MAM1E,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,WAAW,MAAM,KAAG,KAAK,CAAC,QAMxE,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE,WAAW,MAAM,WAa1F,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE,WAAW,MAAM,uBAS7F,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,QAAQ,KAAK,CAAC,MAAM,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE,WAAW,MAAM,KAAG,MAc7F,CAAA;AAED,eAAO,MAAM,eAAe,GAC3B,QAAQ,KAAK,CAAC,MAAM,EACpB,QAAQ,KAAK,CAAC,MAAM,EACpB,cAAc,MAAM,KAClB,KAAK,CAAC,MAAM,GAAG,IAKjB,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,CAAC,EACxC,QAAQ,KAAK,CAAC,MAAM,EACpB,QAAQ,MAAM,GAAG,KAAK,CAAC,MAAM,EAC7B,SAAS,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAC5B;IAAE,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,CAAA;CAQ1B,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,EACnC,QAAQ,KAAK,CAAC,MAAM,EACpB,QAAQ,MAAM,GAAG,KAAK,CAAC,MAAM,EAC7B,OAAO,MAAM,GAAG,KAAK,CAAC,QAAQ,EAC9B,SAAS,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,KAC5B,CA0CF,CAAA;AAED,eAAO,MAAM,yBAAyB,GAAI,CAAC,EAC1C,QAAQ,KAAK,CAAC,MAAM,EACpB,QAAQ,MAAM,GAAG,KAAK,CAAC,MAAM,EAC7B,UAAU,MAAM,GAAG,KAAK,CAAC,WAAW,EACpC,SAAS,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC,KACrC,CAiFF,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,OAAO,KAAK,CAAC,QAAQ,KAAG,KAAK,IAAI,KAAK,CAAC,WAEjE,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,UAAU,KAAK,CAAC,QAAQ,KAAG,QAAQ,IAAI,KAAK,CAAC,eAE9E,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,UAAU,KAAK,CAAC,QAAQ,KAAG,QAAQ,IAAI,KAAK,CAAC,cAE7E,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,CAAC,QAAQ,KAAG,KAAK,IAAI,KAAK,CAAC,SAAuD,CAAA;AAEvH,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,MAAoC,CAAA"}

package/dist/types/model/resolveDefaultColumnType.d.ts

@@ -0,0 +1,3 @@
+import { Model } from '@contember/schema';
+export declare const resolveDefaultColumnType: (type: Exclude<Model.ColumnType, Model.ColumnType.Enum>) => string;
+//# sourceMappingURL=resolveDefaultColumnType.d.ts.map

package/dist/types/model/resolveDefaultColumnType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveDefaultColumnType.d.ts","sourceRoot":"","sources":["../../../src/model/resolveDefaultColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGzC,eAAO,MAAM,wBAAwB,GAAI,MAAM,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,KAAG,MAuBjG,CAAA"}

package/dist/types/schemaChecksum.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@contember/schema';
+export declare const calculateSchemaChecksum: (schema: Schema) => string;
+//# sourceMappingURL=schemaChecksum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaChecksum.d.ts","sourceRoot":"","sources":["../../src/schemaChecksum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAG1C,eAAO,MAAM,uBAAuB,GAAI,QAAQ,MAAM,KAAG,MAOxD,CAAA"}

package/dist/types/schemaFilter.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@contember/schema';
+export declare const filterSchemaByStage: <S extends Schema>(schema: S, stageSlug: string) => S;
+//# sourceMappingURL=schemaFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaFilter.d.ts","sourceRoot":"","sources":["../../src/schemaFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE1C,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,MAAM,KAAG,CA0BpF,CAAA"}

package/dist/types/schemaNormalizer.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@contember/schema';
+export declare const normalizeSchema: <S extends Schema>(schema: S) => S;
+//# sourceMappingURL=schemaNormalizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaNormalizer.d.ts","sourceRoot":"","sources":["../../src/schemaNormalizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAG5D,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,KAAG,CAkE7D,CAAA"}