orcaq 1.0.20

package/.output/server/node_modules/typeorm/error/CustomRepositoryCannotInheritRepositoryError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomRepositoryCannotInheritRepositoryError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown if custom repository inherits Repository class however entity is not set in @EntityRepository decorator.
+ */
+class CustomRepositoryCannotInheritRepositoryError extends TypeORMError_1.TypeORMError {
+    constructor(repository) {
+        super(`Custom entity repository ${typeof repository === "function"
+            ? repository.name
+            : repository.constructor.name} ` +
+            ` cannot inherit Repository class without entity being set in the @EntityRepository decorator.`);
+    }
+}
+exports.CustomRepositoryCannotInheritRepositoryError = CustomRepositoryCannotInheritRepositoryError;
+
+//# sourceMappingURL=CustomRepositoryCannotInheritRepositoryError.js.map

package/.output/server/node_modules/typeorm/error/CustomRepositoryDoesNotHaveEntityError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomRepositoryDoesNotHaveEntityError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown if custom repositories that extend AbstractRepository classes does not have managed entity.
+ */
+class CustomRepositoryDoesNotHaveEntityError extends TypeORMError_1.TypeORMError {
+    constructor(repository) {
+        super(`Custom repository ${typeof repository === "function"
+            ? repository.name
+            : repository.constructor.name} does not have managed entity. ` +
+            `Did you forget to specify entity for it @EntityRepository(MyEntity)? `);
+    }
+}
+exports.CustomRepositoryDoesNotHaveEntityError = CustomRepositoryDoesNotHaveEntityError;
+
+//# sourceMappingURL=CustomRepositoryDoesNotHaveEntityError.js.map

package/.output/server/node_modules/typeorm/error/CustomRepositoryNotFoundError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomRepositoryNotFoundError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown if custom repository was not found.
+ */
+class CustomRepositoryNotFoundError extends TypeORMError_1.TypeORMError {
+    constructor(repository) {
+        super(`Custom repository ${typeof repository === "function"
+            ? repository.name
+            : repository.constructor.name} was not found. ` +
+            `Did you forgot to put @EntityRepository decorator on it?`);
+    }
+}
+exports.CustomRepositoryNotFoundError = CustomRepositoryNotFoundError;
+
+//# sourceMappingURL=CustomRepositoryNotFoundError.js.map

package/.output/server/node_modules/typeorm/error/DataTypeNotSupportedError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTypeNotSupportedError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class DataTypeNotSupportedError extends TypeORMError_1.TypeORMError {
+    constructor(column, dataType, database) {
+        super();
+        const type = typeof dataType === "string" ? dataType : dataType.name;
+        this.message = `Data type "${type}" in "${column.entityMetadata.targetName}.${column.propertyName}" is not supported by "${database}" database.`;
+    }
+}
+exports.DataTypeNotSupportedError = DataTypeNotSupportedError;
+
+//# sourceMappingURL=DataTypeNotSupportedError.js.map

package/.output/server/node_modules/typeorm/error/DriverOptionNotSetError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriverOptionNotSetError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown if some required driver's option is not set.
+ */
+class DriverOptionNotSetError extends TypeORMError_1.TypeORMError {
+    constructor(optionName) {
+        super(`Driver option (${optionName}) is not set. ` +
+            `Please set it to perform connection to the database.`);
+    }
+}
+exports.DriverOptionNotSetError = DriverOptionNotSetError;
+
+//# sourceMappingURL=DriverOptionNotSetError.js.map

package/.output/server/node_modules/typeorm/error/DriverPackageNotInstalledError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriverPackageNotInstalledError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when required driver's package is not installed.
+ */
+class DriverPackageNotInstalledError extends TypeORMError_1.TypeORMError {
+    constructor(driverName, packageName) {
+        super(`${driverName} package has not been found installed. ` +
+            `Try to install it: npm install ${packageName} --save`);
+    }
+}
+exports.DriverPackageNotInstalledError = DriverPackageNotInstalledError;
+
+//# sourceMappingURL=DriverPackageNotInstalledError.js.map

package/.output/server/node_modules/typeorm/error/EntityMetadataNotFoundError.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityMetadataNotFoundError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+class EntityMetadataNotFoundError extends TypeORMError_1.TypeORMError {
+    constructor(target) {
+        super();
+        this.message = `No metadata for "${this.stringifyTarget(target)}" was found.`;
+    }
+    stringifyTarget(target) {
+        if (InstanceChecker_1.InstanceChecker.isEntitySchema(target)) {
+            return target.options.name;
+        }
+        else if (typeof target === "function") {
+            return target.name;
+        }
+        else if (ObjectUtils_1.ObjectUtils.isObject(target) && "name" in target) {
+            return target.name;
+        }
+        else {
+            return target;
+        }
+    }
+}
+exports.EntityMetadataNotFoundError = EntityMetadataNotFoundError;
+
+//# sourceMappingURL=EntityMetadataNotFoundError.js.map

package/.output/server/node_modules/typeorm/error/EntityNotFoundError.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityNotFoundError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+const ObjectUtils_1 = require("../util/ObjectUtils");
+const InstanceChecker_1 = require("../util/InstanceChecker");
+/**
+ * Thrown when no result could be found in methods which are not allowed to return undefined or an empty set.
+ */
+class EntityNotFoundError extends TypeORMError_1.TypeORMError {
+    constructor(entityClass, criteria) {
+        super();
+        this.entityClass = entityClass;
+        this.criteria = criteria;
+        this.message =
+            `Could not find any entity of type "${this.stringifyTarget(entityClass)}" ` + `matching: ${this.stringifyCriteria(criteria)}`;
+    }
+    stringifyTarget(target) {
+        if (InstanceChecker_1.InstanceChecker.isEntitySchema(target)) {
+            return target.options.name;
+        }
+        else if (typeof target === "function") {
+            return target.name;
+        }
+        else if (ObjectUtils_1.ObjectUtils.isObject(target) && "name" in target) {
+            return target.name;
+        }
+        else {
+            return target;
+        }
+    }
+    stringifyCriteria(criteria) {
+        try {
+            return JSON.stringify(criteria, null, 4);
+        }
+        catch (e) { }
+        return "" + criteria;
+    }
+}
+exports.EntityNotFoundError = EntityNotFoundError;
+
+//# sourceMappingURL=EntityNotFoundError.js.map

package/.output/server/node_modules/typeorm/error/EntityPropertyNotFoundError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityPropertyNotFoundError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when specified entity property was not found.
+ */
+class EntityPropertyNotFoundError extends TypeORMError_1.TypeORMError {
+    constructor(propertyPath, metadata) {
+        super(propertyPath);
+        Object.setPrototypeOf(this, EntityPropertyNotFoundError.prototype);
+        this.message = `Property "${propertyPath}" was not found in "${metadata.targetName}". Make sure your query is correct.`;
+    }
+}
+exports.EntityPropertyNotFoundError = EntityPropertyNotFoundError;
+
+//# sourceMappingURL=EntityPropertyNotFoundError.js.map

package/.output/server/node_modules/typeorm/error/FindRelationsNotFoundError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindRelationsNotFoundError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when relations specified in the find options were not found in the entities.
+ */
+class FindRelationsNotFoundError extends TypeORMError_1.TypeORMError {
+    constructor(notFoundRelations) {
+        super();
+        if (notFoundRelations.length === 1) {
+            this.message = `Relation "${notFoundRelations[0]}" was not found; please check if it is correct and really exists in your entity.`;
+        }
+        else {
+            this.message = `Relations ${notFoundRelations
+                .map((relation) => `"${relation}"`)
+                .join(", ")} were not found; please check if relations are correct and they exist in your entities.`;
+        }
+    }
+}
+exports.FindRelationsNotFoundError = FindRelationsNotFoundError;
+
+//# sourceMappingURL=FindRelationsNotFoundError.js.map

package/.output/server/node_modules/typeorm/error/ForbiddenTransactionModeOverrideError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForbiddenTransactionModeOverrideError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when the per-migration transaction mode is overriden but the global transaction mode is set to "all".
+ */
+class ForbiddenTransactionModeOverrideError extends TypeORMError_1.TypeORMError {
+    constructor(migrationsOverridingTransactionMode) {
+        const migrationNames = migrationsOverridingTransactionMode.map((migration) => `"${migration.name}"`);
+        super(`Migrations ${migrationNames.join(", ")} override the transaction mode, but the global transaction mode is "all"`);
+    }
+}
+exports.ForbiddenTransactionModeOverrideError = ForbiddenTransactionModeOverrideError;
+
+//# sourceMappingURL=ForbiddenTransactionModeOverrideError.js.map

package/.output/server/node_modules/typeorm/error/InitializedRelationError.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializedRelationError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when relation has array initialized which is forbidden my ORM.
+ *
+ * @see https://github.com/typeorm/typeorm/issues/1319
+ * @see http://typeorm.io/#/relations-faq/avoid-relation-property-initializers
+ */
+class InitializedRelationError extends TypeORMError_1.TypeORMError {
+    constructor(relation) {
+        super(`Array initializations are not allowed in entity relations. ` +
+            `Please remove array initialization (= []) from "${relation.entityMetadata.targetName}#${relation.propertyPath}". ` +
+            `This is ORM requirement to make relations to work properly. Refer docs for more information.`);
+    }
+}
+exports.InitializedRelationError = InitializedRelationError;
+
+//# sourceMappingURL=InitializedRelationError.js.map

package/.output/server/node_modules/typeorm/error/InsertValuesMissingError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertValuesMissingError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when user tries to insert using QueryBuilder but do not specify what to insert.
+ */
+class InsertValuesMissingError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`Cannot perform insert query because values are not defined. ` +
+            `Call "qb.values(...)" method to specify inserted values.`);
+    }
+}
+exports.InsertValuesMissingError = InsertValuesMissingError;
+
+//# sourceMappingURL=InsertValuesMissingError.js.map

package/.output/server/node_modules/typeorm/error/LimitOnUpdateNotSupportedError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitOnUpdateNotSupportedError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when user tries to build an UPDATE query with LIMIT but the database does not support it.
+ */
+class LimitOnUpdateNotSupportedError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`Your database does not support LIMIT on UPDATE statements.`);
+    }
+}
+exports.LimitOnUpdateNotSupportedError = LimitOnUpdateNotSupportedError;
+
+//# sourceMappingURL=LimitOnUpdateNotSupportedError.js.map

package/.output/server/node_modules/typeorm/error/LockNotSupportedOnGivenDriverError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockNotSupportedOnGivenDriverError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when selected sql driver does not supports locking.
+ */
+class LockNotSupportedOnGivenDriverError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`Locking not supported on given driver.`);
+    }
+}
+exports.LockNotSupportedOnGivenDriverError = LockNotSupportedOnGivenDriverError;
+
+//# sourceMappingURL=LockNotSupportedOnGivenDriverError.js.map

package/.output/server/node_modules/typeorm/error/MetadataAlreadyExistsError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataAlreadyExistsError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class MetadataAlreadyExistsError extends TypeORMError_1.TypeORMError {
+    constructor(metadataType, constructor, propertyName) {
+        super(metadataType +
+            " metadata already exists for the class constructor " +
+            JSON.stringify(constructor) +
+            (propertyName
+                ? " on property " + propertyName
+                : ". If you previously renamed or moved entity class, make sure" +
+                    " that compiled version of old entity class source wasn't left in the compiler output directory."));
+    }
+}
+exports.MetadataAlreadyExistsError = MetadataAlreadyExistsError;
+
+//# sourceMappingURL=MetadataAlreadyExistsError.js.map

package/.output/server/node_modules/typeorm/error/MetadataWithSuchNameAlreadyExistsError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataWithSuchNameAlreadyExistsError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class MetadataWithSuchNameAlreadyExistsError extends TypeORMError_1.TypeORMError {
+    constructor(metadataType, name) {
+        super(metadataType +
+            " metadata with such name " +
+            name +
+            " already exists. " +
+            "Do you apply decorator twice? Or maybe try to change a name?");
+    }
+}
+exports.MetadataWithSuchNameAlreadyExistsError = MetadataWithSuchNameAlreadyExistsError;
+
+//# sourceMappingURL=MetadataWithSuchNameAlreadyExistsError.js.map

package/.output/server/node_modules/typeorm/error/MissingDeleteDateColumnError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingDeleteDateColumnError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class MissingDeleteDateColumnError extends TypeORMError_1.TypeORMError {
+    constructor(entityMetadata) {
+        super(`Entity "${entityMetadata.name}" does not have delete date columns.`);
+    }
+}
+exports.MissingDeleteDateColumnError = MissingDeleteDateColumnError;
+
+//# sourceMappingURL=MissingDeleteDateColumnError.js.map

package/.output/server/node_modules/typeorm/error/MissingDriverError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingDriverError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when consumer specifies driver type that does not exist or supported.
+ */
+class MissingDriverError extends TypeORMError_1.TypeORMError {
+    constructor(driverType, availableDrivers = []) {
+        super(`Wrong driver: "${driverType}" given. Supported drivers are: ` +
+            `${availableDrivers.map((d) => `"${d}"`).join(", ")}.`);
+    }
+}
+exports.MissingDriverError = MissingDriverError;
+
+//# sourceMappingURL=MissingDriverError.js.map

package/.output/server/node_modules/typeorm/error/MissingJoinColumnError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingJoinColumnError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class MissingJoinColumnError extends TypeORMError_1.TypeORMError {
+    constructor(entityMetadata, relation) {
+        super();
+        if (relation.inverseRelation) {
+            this.message =
+                `JoinColumn is missing on both sides of ${entityMetadata.name}#${relation.propertyName} and ` +
+                    `${relation.inverseEntityMetadata.name}#${relation.inverseRelation.propertyName} one-to-one relationship. ` +
+                    `You need to put JoinColumn decorator on one of the sides.`;
+        }
+        else {
+            this.message =
+                `JoinColumn is missing on ${entityMetadata.name}#${relation.propertyName} one-to-one relationship. ` +
+                    `You need to put JoinColumn decorator on it.`;
+        }
+    }
+}
+exports.MissingJoinColumnError = MissingJoinColumnError;
+
+//# sourceMappingURL=MissingJoinColumnError.js.map

package/.output/server/node_modules/typeorm/error/MissingJoinTableError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingJoinTableError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class MissingJoinTableError extends TypeORMError_1.TypeORMError {
+    constructor(entityMetadata, relation) {
+        super();
+        if (relation.inverseRelation) {
+            this.message =
+                `JoinTable is missing on both sides of ${entityMetadata.name}#${relation.propertyName} and ` +
+                    `${relation.inverseEntityMetadata.name}#${relation.inverseRelation.propertyName} many-to-many relationship. ` +
+                    `You need to put decorator decorator on one of the sides.`;
+        }
+        else {
+            this.message =
+                `JoinTable is missing on ${entityMetadata.name}#${relation.propertyName} many-to-many relationship. ` +
+                    `You need to put JoinTable decorator on it.`;
+        }
+    }
+}
+exports.MissingJoinTableError = MissingJoinTableError;
+
+//# sourceMappingURL=MissingJoinTableError.js.map

package/.output/server/node_modules/typeorm/error/MissingPrimaryColumnError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingPrimaryColumnError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class MissingPrimaryColumnError extends TypeORMError_1.TypeORMError {
+    constructor(entityMetadata) {
+        super(`Entity "${entityMetadata.name}" does not have a primary column. Primary column is required to ` +
+            `have in all your entities. Use @PrimaryColumn decorator to add a primary column to your entity.`);
+    }
+}
+exports.MissingPrimaryColumnError = MissingPrimaryColumnError;
+
+//# sourceMappingURL=MissingPrimaryColumnError.js.map

package/.output/server/node_modules/typeorm/error/MustBeEntityError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MustBeEntityError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when method expects entity but instead something else is given.
+ */
+class MustBeEntityError extends TypeORMError_1.TypeORMError {
+    constructor(operation, wrongValue) {
+        super(`Cannot ${operation}, given value must be an entity, instead "${wrongValue}" is given.`);
+    }
+}
+exports.MustBeEntityError = MustBeEntityError;
+
+//# sourceMappingURL=MustBeEntityError.js.map

package/.output/server/node_modules/typeorm/error/NestedSetMultipleRootError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedSetMultipleRootError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class NestedSetMultipleRootError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`Nested sets do not support multiple root entities.`);
+    }
+}
+exports.NestedSetMultipleRootError = NestedSetMultipleRootError;
+
+//# sourceMappingURL=NestedSetMultipleRootError.js.map

package/.output/server/node_modules/typeorm/error/NoConnectionForRepositoryError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoConnectionForRepositoryError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when consumer tries to access repository before connection is established.
+ */
+class NoConnectionForRepositoryError extends TypeORMError_1.TypeORMError {
+    constructor(connectionName) {
+        super(`Cannot get a Repository for "${connectionName} connection, because connection with the database ` +
+            `is not established yet. Call connection#connect method to establish connection.`);
+    }
+}
+exports.NoConnectionForRepositoryError = NoConnectionForRepositoryError;
+
+//# sourceMappingURL=NoConnectionForRepositoryError.js.map

package/.output/server/node_modules/typeorm/error/NoConnectionOptionError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoConnectionOptionError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when some option is not set in the connection options.
+ */
+class NoConnectionOptionError extends TypeORMError_1.TypeORMError {
+    constructor(optionName) {
+        super(`Option "${optionName}" is not set in your connection options, please ` +
+            `define "${optionName}" option in your connection options or ormconfig.json`);
+    }
+}
+exports.NoConnectionOptionError = NoConnectionOptionError;
+
+//# sourceMappingURL=NoConnectionOptionError.js.map

package/.output/server/node_modules/typeorm/error/NoNeedToReleaseEntityManagerError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoNeedToReleaseEntityManagerError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when consumer tries to release entity manager that does not use single database connection.
+ */
+class NoNeedToReleaseEntityManagerError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`Entity manager is not using single database connection and cannot be released. ` +
+            `Only entity managers created by connection#createEntityManagerWithSingleDatabaseConnection ` +
+            `methods have a single database connection and they should be released.`);
+    }
+}
+exports.NoNeedToReleaseEntityManagerError = NoNeedToReleaseEntityManagerError;
+
+//# sourceMappingURL=NoNeedToReleaseEntityManagerError.js.map

package/.output/server/node_modules/typeorm/error/NoVersionOrUpdateDateColumnError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoVersionOrUpdateDateColumnError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when an entity does not have no version and no update date column.
+ */
+class NoVersionOrUpdateDateColumnError extends TypeORMError_1.TypeORMError {
+    constructor(entity) {
+        super(`Entity ${entity} does not have version or update date columns.`);
+    }
+}
+exports.NoVersionOrUpdateDateColumnError = NoVersionOrUpdateDateColumnError;
+
+//# sourceMappingURL=NoVersionOrUpdateDateColumnError.js.map

package/.output/server/node_modules/typeorm/error/OffsetWithoutLimitNotSupportedError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffsetWithoutLimitNotSupportedError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when user tries to build SELECT query using OFFSET without LIMIT applied but database does not support it.
+ */
+class OffsetWithoutLimitNotSupportedError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`RDBMS does not support OFFSET without LIMIT in SELECT statements. You must use limit in ` +
+            `conjunction with offset function (or take in conjunction with skip function if you are ` +
+            `using pagination).`);
+    }
+}
+exports.OffsetWithoutLimitNotSupportedError = OffsetWithoutLimitNotSupportedError;
+
+//# sourceMappingURL=OffsetWithoutLimitNotSupportedError.js.map

package/.output/server/node_modules/typeorm/error/OptimisticLockCanNotBeUsedError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimisticLockCanNotBeUsedError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when an optimistic lock cannot be used in query builder.
+ */
+class OptimisticLockCanNotBeUsedError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`The optimistic lock can be used only with getOne() method.`);
+    }
+}
+exports.OptimisticLockCanNotBeUsedError = OptimisticLockCanNotBeUsedError;
+
+//# sourceMappingURL=OptimisticLockCanNotBeUsedError.js.map

package/.output/server/node_modules/typeorm/error/OptimisticLockVersionMismatchError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimisticLockVersionMismatchError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when a version check on an object that uses optimistic locking through a version field fails.
+ */
+class OptimisticLockVersionMismatchError extends TypeORMError_1.TypeORMError {
+    constructor(entity, expectedVersion, actualVersion) {
+        super(`The optimistic lock on entity ${entity} failed, version ${expectedVersion} was expected, but is actually ${actualVersion}.`);
+    }
+}
+exports.OptimisticLockVersionMismatchError = OptimisticLockVersionMismatchError;
+
+//# sourceMappingURL=OptimisticLockVersionMismatchError.js.map

package/.output/server/node_modules/typeorm/error/PersistedEntityNotFoundError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistedEntityNotFoundError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown . Theoretically can't be thrown.
+ */
+class PersistedEntityNotFoundError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`Internal error. Persisted entity was not found in the list of prepared operated entities.`);
+    }
+}
+exports.PersistedEntityNotFoundError = PersistedEntityNotFoundError;
+
+//# sourceMappingURL=PersistedEntityNotFoundError.js.map

package/.output/server/node_modules/typeorm/error/PessimisticLockTransactionRequiredError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PessimisticLockTransactionRequiredError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+/**
+ * Thrown when a transaction is required for the current operation, but there is none open.
+ */
+class PessimisticLockTransactionRequiredError extends TypeORMError_1.TypeORMError {
+    constructor() {
+        super(`An open transaction is required for pessimistic lock.`);
+    }
+}
+exports.PessimisticLockTransactionRequiredError = PessimisticLockTransactionRequiredError;
+
+//# sourceMappingURL=PessimisticLockTransactionRequiredError.js.map

package/.output/server/node_modules/typeorm/error/PrimaryColumnCannotBeNullableError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryColumnCannotBeNullableError = void 0;
+const TypeORMError_1 = require("./TypeORMError");
+class PrimaryColumnCannotBeNullableError extends TypeORMError_1.TypeORMError {
+    constructor(object, propertyName) {
+        super(`Primary column ${object.constructor.name}#${propertyName} cannot be nullable. ` +
+            `Its not allowed for primary keys. Try to remove nullable option.`);
+    }
+}
+exports.PrimaryColumnCannotBeNullableError = PrimaryColumnCannotBeNullableError;
+
+//# sourceMappingURL=PrimaryColumnCannotBeNullableError.js.map