@expo/entity 0.60.0 → 0.62.0

package/build/src/errors/EntityDatabaseAdapterError.js

@@ -1,225 +1,207 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityDatabaseAdapterPaginationCursorInvalidError = exports.EntityDatabaseAdapterExcessiveDeleteResultError = exports.EntityDatabaseAdapterEmptyUpdateResultError = exports.EntityDatabaseAdapterExcessiveUpdateResultError = exports.EntityDatabaseAdapterEmptyInsertResultError = exports.EntityDatabaseAdapterExcessiveInsertResultError = exports.EntityDatabaseAdapterUniqueConstraintError = exports.EntityDatabaseAdapterNotNullConstraintError = exports.EntityDatabaseAdapterForeignKeyConstraintError = exports.EntityDatabaseAdapterExclusionConstraintError = exports.EntityDatabaseAdapterCheckConstraintError = exports.EntityDatabaseAdapterUnknownError = exports.EntityDatabaseAdapterTransientError = exports.EntityDatabaseAdapterError = void 0;
-const EntityError_1 = require("./EntityError");
+import { EntityError, EntityErrorCode, EntityErrorState } from "./EntityError.js";
 /**
  * Base class for all errors related to the database adapter.
  */
-class EntityDatabaseAdapterError extends EntityError_1.EntityError {
+export class EntityDatabaseAdapterError extends EntityError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterError';
     }
 }
-exports.EntityDatabaseAdapterError = EntityDatabaseAdapterError;
 /**
  * Thrown when a transient error occurrs within the database adapter.
  * Transient errors may succeed if retried.
  */
-class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterTransientError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.TRANSIENT;
+        return EntityErrorState.TRANSIENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
     }
 }
-exports.EntityDatabaseAdapterTransientError = EntityDatabaseAdapterTransientError;
 /**
  * Thrown when an unknown error occurrs within the database adapter.
  * This is a catch-all error class for DBMS-specific errors that do not fit into other categories.
  */
-class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterUnknownError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.UNKNOWN;
+        return EntityErrorState.UNKNOWN;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
     }
 }
-exports.EntityDatabaseAdapterUnknownError = EntityDatabaseAdapterUnknownError;
 /**
  * Thrown when a check constraint is violated within the database adapter.
  * This indicates that a value being inserted or updated does not satisfy a defined data integrity constraint.
  */
-class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterCheckConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterCheckConstraintError = EntityDatabaseAdapterCheckConstraintError;
 /**
  * Thrown when an exclusion constraint is violated within the database adapter.
  * This indicates that a value being inserted or updated conflicts with an existing value based on a defined exclusion constraint.
  */
-class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExclusionConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterExclusionConstraintError = EntityDatabaseAdapterExclusionConstraintError;
 /**
  * Thrown when a foreign key constraint is violated within the database adapter.
  * This indicates that a value being inserted, updated, or deleted references a non-existent value in a related table
  * or is referenced in a related table.
  */
-class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterForeignKeyConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterForeignKeyConstraintError = EntityDatabaseAdapterForeignKeyConstraintError;
 /**
  * Thrown when a not-null constraint is violated within the database adapter.
  * This indicates that a null value is being inserted or updated into a column that does not allow null values.
  */
-class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterNotNullConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterNotNullConstraintError = EntityDatabaseAdapterNotNullConstraintError;
 /**
  * Thrown when a unique constraint is violated within the database adapter.
  * This indicates that a value being inserted or updated duplicates an existing value in a column or set of columns
  * that require unique values.
  */
-class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterUniqueConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterUniqueConstraintError = EntityDatabaseAdapterUniqueConstraintError;
 /**
  * Thrown when an insert operation returns more results than expected. Only one row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying database has nonstandard
  * triggers or something similar.
  */
-class EntityDatabaseAdapterExcessiveInsertResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExcessiveInsertResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExcessiveInsertResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT;
     }
 }
-exports.EntityDatabaseAdapterExcessiveInsertResultError = EntityDatabaseAdapterExcessiveInsertResultError;
 /**
  * Thrown when an insert operation returns no results. One row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying database has nonstandard
  * triggers or something similar.
  */
-class EntityDatabaseAdapterEmptyInsertResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterEmptyInsertResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterEmptyInsertResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT;
     }
 }
-exports.EntityDatabaseAdapterEmptyInsertResultError = EntityDatabaseAdapterEmptyInsertResultError;
 /**
  * Thrown when an update operation returns more results than expected. Only one row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying table has a non-unique
  * primary key column.
  */
-class EntityDatabaseAdapterExcessiveUpdateResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExcessiveUpdateResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExcessiveUpdateResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT;
     }
 }
-exports.EntityDatabaseAdapterExcessiveUpdateResultError = EntityDatabaseAdapterExcessiveUpdateResultError;
 /**
  * Thrown when an update operation returns no results. One row is expected.
  * This most often happens when attempting to update a non-existent row, often indicating that the row
  * was deleted by a different process between fetching and updating it in this process.
  */
-class EntityDatabaseAdapterEmptyUpdateResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterEmptyUpdateResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterEmptyUpdateResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT;
     }
 }
-exports.EntityDatabaseAdapterEmptyUpdateResultError = EntityDatabaseAdapterEmptyUpdateResultError;
 /**
  * Thrown when a delete operation returns more results than expected. Only one row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying table has a non-unique
  * primary key column.
  */
-class EntityDatabaseAdapterExcessiveDeleteResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExcessiveDeleteResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExcessiveDeleteResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
     }
 }
-exports.EntityDatabaseAdapterExcessiveDeleteResultError = EntityDatabaseAdapterExcessiveDeleteResultError;
-class EntityDatabaseAdapterPaginationCursorInvalidError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterPaginationCursorInvalidError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterPaginationCursorError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID;
     }
 }
-exports.EntityDatabaseAdapterPaginationCursorInvalidError = EntityDatabaseAdapterPaginationCursorInvalidError;
-//# sourceMappingURL=EntityDatabaseAdapterError.js.map

package/build/src/errors/EntityError.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityError = exports.EntityErrorCode = exports.EntityErrorState = void 0;
 /**
  * The state of an entity error, indicating whether it may be transient/retryable.
  */
-var EntityErrorState;
+export var EntityErrorState;
 (function (EntityErrorState) {
     EntityErrorState[EntityErrorState["UNKNOWN"] = 0] = "UNKNOWN";
     EntityErrorState[EntityErrorState["TRANSIENT"] = 1] = "TRANSIENT";
     EntityErrorState[EntityErrorState["PERMANENT"] = 2] = "PERMANENT";
-})(EntityErrorState || (exports.EntityErrorState = EntityErrorState = {}));
+})(EntityErrorState || (EntityErrorState = {}));
 /**
  * Error code for an entity error. Each error code should map to a specific class of Entity error.
  */
-var EntityErrorCode;
+export var EntityErrorCode;
 (function (EntityErrorCode) {
     EntityErrorCode["ERR_ENTITY_NOT_AUTHORIZED"] = "ERR_ENTITY_NOT_AUTHORIZED";
     EntityErrorCode["ERR_ENTITY_NOT_FOUND"] = "ERR_ENTITY_NOT_FOUND";
@@ -32,11 +29,11 @@ var EntityErrorCode;
     EntityErrorCode["ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT"] = "ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT";
     EntityErrorCode["ERR_ENTITY_CACHE_ADAPTER_TRANSIENT"] = "ERR_ENTITY_CACHE_ADAPTER_TRANSIENT";
     EntityErrorCode["ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID"] = "ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID";
-})(EntityErrorCode || (exports.EntityErrorCode = EntityErrorCode = {}));
+})(EntityErrorCode || (EntityErrorCode = {}));
 /**
  * Base class for all known errors thrown by the entity system.
  */
-class EntityError extends Error {
+export class EntityError extends Error {
     static {
         this.prototype.name = 'EntityError';
     }
@@ -44,5 +41,3 @@ class EntityError extends Error {
         super(message, { cause });
     }
 }
-exports.EntityError = EntityError;
-//# sourceMappingURL=EntityError.js.map

package/build/src/errors/EntityInvalidFieldValueError.d.ts

@@ -1,8 +1,8 @@
-import { IEntityClass } from '../Entity';
-import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
-import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
+import type { IEntityClass } from '../Entity.ts';
+import type { EntityPrivacyPolicy } from '../EntityPrivacyPolicy.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError.ts';
 /**
  * Error thrown when an entity field has an invalid value, either during load or mutation.
  */

package/build/src/errors/EntityInvalidFieldValueError.js

@@ -1,23 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityInvalidFieldValueError = void 0;
-const EntityError_1 = require("./EntityError");
+import { EntityError, EntityErrorCode, EntityErrorState } from "./EntityError.js";
 /**
  * Error thrown when an entity field has an invalid value, either during load or mutation.
  */
-class EntityInvalidFieldValueError extends EntityError_1.EntityError {
+export class EntityInvalidFieldValueError extends EntityError {
     static {
         this.prototype.name = 'EntityInvalidFieldValueError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE;
+        return EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE;
     }
     constructor(entityClass, fieldName, fieldValue) {
         super(`Entity field not valid: ${entityClass.name} (${String(fieldName)} = ${fieldValue})`);
     }
 }
-exports.EntityInvalidFieldValueError = EntityInvalidFieldValueError;
-//# sourceMappingURL=EntityInvalidFieldValueError.js.map

package/build/src/errors/EntityNotAuthorizedError.d.ts

@@ -1,7 +1,7 @@
-import { EntityAuthorizationAction } from '../EntityPrivacyPolicy';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
-import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
+import { EntityAuthorizationAction } from '../EntityPrivacyPolicy.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError.ts';
 /**
  * Error thrown when viewer context is not authorized to perform an action on an entity.
  */

package/build/src/errors/EntityNotAuthorizedError.js

@@ -1,26 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityNotAuthorizedError = void 0;
-const EntityPrivacyPolicy_1 = require("../EntityPrivacyPolicy");
-const EntityError_1 = require("./EntityError");
+import { EntityAuthorizationAction } from "../EntityPrivacyPolicy.js";
+import { EntityError, EntityErrorCode, EntityErrorState } from "./EntityError.js";
 /**
  * Error thrown when viewer context is not authorized to perform an action on an entity.
  */
-class EntityNotAuthorizedError extends EntityError_1.EntityError {
+export class EntityNotAuthorizedError extends EntityError {
     static {
         this.prototype.name = 'EntityNotAuthorizedError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
+        return EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
     }
     entityClassName;
     constructor(entity, viewerContext, action, ruleIndex) {
-        super(`Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityPrivacyPolicy_1.EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`);
+        super(`Entity not authorized: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${ruleIndex})`);
         this.entityClassName = entity.constructor.name;
     }
 }
-exports.EntityNotAuthorizedError = EntityNotAuthorizedError;
-//# sourceMappingURL=EntityNotAuthorizedError.js.map

package/build/src/errors/EntityNotFoundError.d.ts

@@ -1,8 +1,8 @@
-import { IEntityClass } from '../Entity';
-import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
-import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
+import type { IEntityClass } from '../Entity.ts';
+import type { EntityPrivacyPolicy } from '../EntityPrivacyPolicy.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError.ts';
 type EntityNotFoundOptions<TFields extends Record<string, any>, TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>, TViewerContext extends ViewerContext, TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>, TPrivacyPolicy extends EntityPrivacyPolicy<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>, N extends keyof TFields, TSelectedFields extends keyof TFields = keyof TFields> = {
     entityClass: IEntityClass<TFields, TIDField, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields>;
     fieldName: N;

package/build/src/errors/EntityNotFoundError.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityNotFoundError = void 0;
-const EntityError_1 = require("./EntityError");
+import { EntityError, EntityErrorCode, EntityErrorState } from "./EntityError.js";
 /**
  * Error thrown when an entity is not found during certain load methods.
  */
-class EntityNotFoundError extends EntityError_1.EntityError {
+export class EntityNotFoundError extends EntityError {
     static {
         this.prototype.name = 'EntityNotFoundError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_NOT_FOUND;
+        return EntityErrorCode.ERR_ENTITY_NOT_FOUND;
     }
     constructor(messageOrOptions) {
         if (typeof messageOrOptions === 'string') {
@@ -24,5 +21,3 @@ class EntityNotFoundError extends EntityError_1.EntityError {
         }
     }
 }
-exports.EntityNotFoundError = EntityNotFoundError;
-//# sourceMappingURL=EntityNotFoundError.js.map

package/build/src/index.d.ts

@@ -2,80 +2,80 @@
  * @packageDocumentation
  * @module @expo/entity
  */
-export * from './AuthorizationResultBasedEntityAssociationLoader';
-export * from './AuthorizationResultBasedEntityLoader';
-export * from './AuthorizationResultBasedEntityMutator';
-export * from './ComposedEntityCacheAdapter';
-export * from './ComposedSecondaryEntityCache';
-export * from './EnforcingEntityAssociationLoader';
-export * from './EnforcingEntityCreator';
-export * from './EnforcingEntityDeleter';
-export * from './EnforcingEntityLoader';
-export * from './EnforcingEntityUpdater';
-export * from './Entity';
-export * from './EntityAssociationLoader';
-export * from './EntityCompanion';
-export * from './EntityCompanionProvider';
-export * from './EntityConfiguration';
-export * from './EntityConstructionUtils';
-export * from './EntityCreator';
-export * from './EntityDatabaseAdapter';
-export * from './EntityDeleter';
-export * from './EntityFieldDefinition';
-export * from './EntityFields';
-export * from './EntityInvalidationUtils';
-export * from './EntityLoader';
-export * from './EntityLoaderFactory';
-export * from './EntityMutationInfo';
-export * from './EntityMutationTriggerConfiguration';
-export * from './EntityMutationValidatorConfiguration';
-export * from './EntityMutatorFactory';
-export * from './EntityPrivacyPolicy';
-export * from './EntityQueryContext';
-export * from './EntityQueryContextProvider';
-export * from './EntitySecondaryCacheLoader';
-export * from './EntityUpdater';
-export * from './entityUtils';
-export * from './GenericEntityCacheAdapter';
-export * from './GenericSecondaryEntityCache';
-export * from './IEntityCacheAdapter';
-export * from './IEntityCacheAdapterProvider';
-export * from './IEntityDatabaseAdapterProvider';
-export * from './IEntityGenericCacher';
-export * from './ReadonlyEntity';
-export * from './ViewerContext';
-export * from './ViewerScopedEntityCompanion';
-export * from './ViewerScopedEntityCompanionProvider';
-export * from './ViewerScopedEntityLoaderFactory';
-export * from './ViewerScopedEntityMutatorFactory';
-export * from './errors/EntityCacheAdapterError';
-export * from './errors/EntityDatabaseAdapterError';
-export * from './errors/EntityError';
-export * from './errors/EntityInvalidFieldValueError';
-export * from './errors/EntityNotAuthorizedError';
-export * from './errors/EntityNotFoundError';
-export * from './internal/CompositeFieldHolder';
-export * from './internal/CompositeFieldValueMap';
-export * from './internal/EntityDataManager';
-export * from './internal/EntityFieldTransformationUtils';
-export * from './internal/EntityLoadInterfaces';
-export * from './internal/EntityTableDataCoordinator';
-export * from './internal/ReadThroughEntityCache';
-export * from './internal/SingleFieldHolder';
-export * from './metrics/EntityMetricsUtils';
-export * from './metrics/IEntityMetricsAdapter';
-export * from './metrics/NoOpEntityMetricsAdapter';
-export * from './rules/AllowIfAllSubRulesAllowPrivacyPolicyRule';
-export * from './rules/AllowIfAnySubRuleAllowsPrivacyPolicyRule';
-export * from './rules/AllowIfInParentCascadeDeletionPrivacyPolicyRule';
-export * from './rules/AlwaysAllowPrivacyPolicyRule';
-export * from './rules/AlwaysDenyPrivacyPolicyRule';
-export * from './rules/AlwaysSkipPrivacyPolicyRule';
-export * from './rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule';
-export * from './rules/PrivacyPolicyRule';
-export * from './utils/EntityCreationUtils';
-export * from './utils/EntityPrivacyUtils';
-export * from './utils/mergeEntityMutationTriggerConfigurations';
-export * from './utils/collections/maps';
-export * from './utils/collections/SerializableKeyMap';
-export * from './utils/collections/sets';
+export * from './AuthorizationResultBasedEntityAssociationLoader.ts';
+export * from './AuthorizationResultBasedEntityLoader.ts';
+export * from './AuthorizationResultBasedEntityMutator.ts';
+export * from './ComposedEntityCacheAdapter.ts';
+export * from './ComposedSecondaryEntityCache.ts';
+export * from './EnforcingEntityAssociationLoader.ts';
+export * from './EnforcingEntityCreator.ts';
+export * from './EnforcingEntityDeleter.ts';
+export * from './EnforcingEntityLoader.ts';
+export * from './EnforcingEntityUpdater.ts';
+export * from './Entity.ts';
+export * from './EntityAssociationLoader.ts';
+export * from './EntityCompanion.ts';
+export * from './EntityCompanionProvider.ts';
+export * from './EntityConfiguration.ts';
+export * from './EntityConstructionUtils.ts';
+export * from './EntityCreator.ts';
+export * from './EntityDatabaseAdapter.ts';
+export * from './EntityDeleter.ts';
+export * from './EntityFieldDefinition.ts';
+export * from './EntityFields.ts';
+export * from './EntityInvalidationUtils.ts';
+export * from './EntityLoader.ts';
+export * from './EntityLoaderFactory.ts';
+export * from './EntityMutationInfo.ts';
+export * from './EntityMutationTriggerConfiguration.ts';
+export * from './EntityMutationValidatorConfiguration.ts';
+export * from './EntityMutatorFactory.ts';
+export * from './EntityPrivacyPolicy.ts';
+export * from './EntityQueryContext.ts';
+export * from './EntityQueryContextProvider.ts';
+export * from './EntitySecondaryCacheLoader.ts';
+export * from './EntityUpdater.ts';
+export * from './entityUtils.ts';
+export * from './GenericEntityCacheAdapter.ts';
+export * from './GenericSecondaryEntityCache.ts';
+export * from './IEntityCacheAdapter.ts';
+export * from './IEntityCacheAdapterProvider.ts';
+export * from './IEntityDatabaseAdapterProvider.ts';
+export * from './IEntityGenericCacher.ts';
+export * from './ReadonlyEntity.ts';
+export * from './ViewerContext.ts';
+export * from './ViewerScopedEntityCompanion.ts';
+export * from './ViewerScopedEntityCompanionProvider.ts';
+export * from './ViewerScopedEntityLoaderFactory.ts';
+export * from './ViewerScopedEntityMutatorFactory.ts';
+export * from './errors/EntityCacheAdapterError.ts';
+export * from './errors/EntityDatabaseAdapterError.ts';
+export * from './errors/EntityError.ts';
+export * from './errors/EntityInvalidFieldValueError.ts';
+export * from './errors/EntityNotAuthorizedError.ts';
+export * from './errors/EntityNotFoundError.ts';
+export * from './internal/CompositeFieldHolder.ts';
+export * from './internal/CompositeFieldValueMap.ts';
+export * from './internal/EntityDataManager.ts';
+export * from './internal/EntityFieldTransformationUtils.ts';
+export * from './internal/EntityLoadInterfaces.ts';
+export * from './internal/EntityTableDataCoordinator.ts';
+export * from './internal/ReadThroughEntityCache.ts';
+export * from './internal/SingleFieldHolder.ts';
+export * from './metrics/EntityMetricsUtils.ts';
+export * from './metrics/IEntityMetricsAdapter.ts';
+export * from './metrics/NoOpEntityMetricsAdapter.ts';
+export * from './rules/AllowIfAllSubRulesAllowPrivacyPolicyRule.ts';
+export * from './rules/AllowIfAnySubRuleAllowsPrivacyPolicyRule.ts';
+export * from './rules/AllowIfInParentCascadeDeletionPrivacyPolicyRule.ts';
+export * from './rules/AlwaysAllowPrivacyPolicyRule.ts';
+export * from './rules/AlwaysDenyPrivacyPolicyRule.ts';
+export * from './rules/AlwaysSkipPrivacyPolicyRule.ts';
+export * from './rules/EvaluateIfEntityFieldPredicatePrivacyPolicyRule.ts';
+export * from './rules/PrivacyPolicyRule.ts';
+export * from './utils/EntityCreationUtils.ts';
+export * from './utils/EntityPrivacyUtils.ts';
+export * from './utils/mergeEntityMutationTriggerConfigurations.ts';
+export * from './utils/collections/maps.ts';
+export * from './utils/collections/SerializableKeyMap.ts';
+export * from './utils/collections/sets.ts';