@hf-chimera/store 0.0.15 → 0.2.0

package/dist/index.d.cts

@@ -1,2 +1,634 @@
-import { $ as ChimeraQueryEntityBatchedCreator, A as ChimeraFilterError, At as ChimeraConjunctionType, B as ChimeraQueryConfig, Bt as ChimeraSimplifiedFilter, C as ChimeraItemQuery, Ct as ChimeraSimplifiedOrderDescriptor, D as chimeraCreateOperator, E as chimeraCreateNot, F as ChimeraCollectionQuery, Ft as ChimeraKeyFromFilterGetter, G as ChimeraQueryDefaultEntityIdGetter, Gt as ChimeraIdGetterFunc, H as ChimeraQueryDefaultBatchedDeleter, Ht as ChimeraEntityGetter, I as ChimeraCollectionQueryEventMap, It as ChimeraKeyFromOperatorGetter, J as ChimeraQueryDefaultItemDeleter, K as ChimeraQueryDefaultEntityIdGetterFunction, Kt as ChimeraMutationRequester, L as ChimeraEntityConfigMap, Lt as ChimeraOperatorFunction, M as ChimeraFilterOperatorNotFoundError, Mt as ChimeraFilterConfig, N as ChimeraError, Nt as ChimeraFilterDescriptor, O as chimeraIsConjunction, Ot as ChimeraConjunctionDescriptor, P as ChimeraInternalError, Pt as ChimeraFilterOperatorDescriptor, Q as ChimeraQueryDeletionResult, R as ChimeraQueryBatchedDeleteResponse, Rt as ChimeraOperatorMap, S as ChimeraStoreConfig, St as ChimeraPrimitiveComparator, T as chimeraCreateConjunction, U as ChimeraQueryDefaultBatchedUpdater, Ut as ChimeraEntityId, V as ChimeraQueryDefaultBatchedCreator, Vt as ChimeraSimplifiedOperator, W as ChimeraQueryDefaultCollectionFetcher, Wt as ChimeraEntityMap, X as ChimeraQueryDefaultItemUpdater, Y as ChimeraQueryDefaultItemFetcher, Z as ChimeraQueryDefaultsConfig, _ as ChimeraStoreEntityType, _t as ChimeraOrderByComparator, a as ChimeraQueryNotSpecifiedError, at as ChimeraQueryEntityFetcherRequestParams, bt as ChimeraOrderNulls, c as ChimeraQueryTrustIdMismatchError, ct as ChimeraQueryEntityItemDeleter, d as ChimeraOrderTypeComparisonError, dt as ChimeraQueryEntityItemUpdater, et as ChimeraQueryEntityBatchedDeleter, f as ChimeraOrderTypeError, ft as ChimeraQueryFetchingStatable, g as ChimeraStoreEntityMap, gt as ChimeraKeyFromOrderGetter, h as ChimeraStoreEntities, ht as ChimeraQueryItemFetcherResponse, i as ChimeraQueryIdMismatchError, it as ChimeraQueryEntityConfig, j as ChimeraFilterOperatorError, jt as ChimeraFilterChecker, k as chimeraIsOperator, kt as ChimeraConjunctionOperationDescriptor, l as chimeraCreateOrderBy, lt as ChimeraQueryEntityItemFetcher, m as ChimeraStore, mt as ChimeraQueryItemDeleteResponse, n as ChimeraWeakValueMapEventMap, nt as ChimeraQueryEntityCollectionFetcher, o as ChimeraQueryTrustError, ot as ChimeraQueryEntityIdGetter, p as AnyChimeraStore, pt as ChimeraQueryFetchingState, q as ChimeraQueryDefaultItemCreator, qt as ChimeraPropertyGetter, r as ChimeraQueryError, rt as ChimeraQueryEntityCollectionFetcherParams, s as ChimeraQueryTrustFetchedCollectionError, st as ChimeraQueryEntityItemCreator, t as ChimeraWeakValueMap, tt as ChimeraQueryEntityBatchedUpdater, u as ChimeraOrderError, ut as ChimeraQueryEntityItemFetcherParams, v as ChimeraStoreOperator, vt as ChimeraOrderConfig, w as ChimeraItemQueryEventMap, x as ChimeraCollectionParams, xt as ChimeraOrderPriority, y as ChimeraStoreOperatorMap, yt as ChimeraOrderDescriptor, z as ChimeraQueryCollectionFetcherResponse, zt as ChimeraSimplifiedConjunctionOperation } from "./index-CkaYmEhA.cjs";
-export { AnyChimeraStore, ChimeraCollectionParams, ChimeraCollectionQuery, ChimeraCollectionQueryEventMap, ChimeraConjunctionDescriptor, ChimeraConjunctionOperationDescriptor, ChimeraConjunctionType, ChimeraEntityConfigMap, ChimeraEntityGetter, ChimeraEntityId, ChimeraEntityMap, ChimeraError, ChimeraFilterChecker, ChimeraFilterConfig, ChimeraFilterDescriptor, ChimeraFilterError, ChimeraFilterOperatorDescriptor, ChimeraFilterOperatorError, ChimeraFilterOperatorNotFoundError, ChimeraIdGetterFunc, ChimeraInternalError, ChimeraItemQuery, ChimeraItemQueryEventMap, ChimeraKeyFromFilterGetter, ChimeraKeyFromOperatorGetter, ChimeraKeyFromOrderGetter, ChimeraMutationRequester, ChimeraOperatorFunction, ChimeraOperatorMap, ChimeraOrderByComparator, ChimeraOrderConfig, ChimeraOrderDescriptor, ChimeraOrderError, ChimeraOrderNulls, ChimeraOrderPriority, ChimeraOrderTypeComparisonError, ChimeraOrderTypeError, ChimeraPrimitiveComparator, ChimeraPropertyGetter, ChimeraQueryBatchedDeleteResponse, ChimeraQueryCollectionFetcherResponse, ChimeraQueryConfig, ChimeraQueryDefaultBatchedCreator, ChimeraQueryDefaultBatchedDeleter, ChimeraQueryDefaultBatchedUpdater, ChimeraQueryDefaultCollectionFetcher, ChimeraQueryDefaultEntityIdGetter, ChimeraQueryDefaultEntityIdGetterFunction, ChimeraQueryDefaultItemCreator, ChimeraQueryDefaultItemDeleter, ChimeraQueryDefaultItemFetcher, ChimeraQueryDefaultItemUpdater, ChimeraQueryDefaultsConfig, ChimeraQueryDeletionResult, ChimeraQueryEntityBatchedCreator, ChimeraQueryEntityBatchedDeleter, ChimeraQueryEntityBatchedUpdater, ChimeraQueryEntityCollectionFetcher, ChimeraQueryEntityCollectionFetcherParams, ChimeraQueryEntityConfig, ChimeraQueryEntityFetcherRequestParams, ChimeraQueryEntityIdGetter, ChimeraQueryEntityItemCreator, ChimeraQueryEntityItemDeleter, ChimeraQueryEntityItemFetcher, ChimeraQueryEntityItemFetcherParams, ChimeraQueryEntityItemUpdater, ChimeraQueryError, ChimeraQueryFetchingStatable, ChimeraQueryFetchingState, ChimeraQueryIdMismatchError, ChimeraQueryItemDeleteResponse, ChimeraQueryItemFetcherResponse, ChimeraQueryNotSpecifiedError, ChimeraQueryTrustError, ChimeraQueryTrustFetchedCollectionError, ChimeraQueryTrustIdMismatchError, ChimeraSimplifiedConjunctionOperation, ChimeraSimplifiedFilter, ChimeraSimplifiedOperator, ChimeraSimplifiedOrderDescriptor, ChimeraStore, ChimeraStoreConfig, ChimeraStoreEntities, ChimeraStoreEntityMap, ChimeraStoreEntityType, ChimeraStoreOperator, ChimeraStoreOperatorMap, ChimeraWeakValueMap, ChimeraWeakValueMapEventMap, chimeraCreateConjunction, chimeraCreateNot, chimeraCreateOperator, chimeraCreateOrderBy, chimeraIsConjunction, chimeraIsOperator };
+import { A as ChimeraPropertyGetter, C as ChimeraOperatorMap, D as SimplifiedConjunction, E as ChimeraSimplifiedOperator, M as DeepPartial, N as KeysOfType, O as ChimeraEntityGetter, P as Nullish, S as ChimeraOperatorFunction, T as ChimeraSimplifiedFilter, _ as ChimeraFilterConfig, a as ChimeraOrderNulls, b as ChimeraKeyFromFilterGetter, c as ChimeraSimplifiedOrderDescriptor, g as ChimeraFilterChecker, h as ChimeraConjunctionType, i as ChimeraOrderDescriptor, j as Constructable, k as ChimeraEntityId, l as chimeraDefaultFilterConfig, m as ChimeraConjunctionOperationDescriptor, n as ChimeraOrderByComparator, o as ChimeraOrderPriority, p as ChimeraConjunctionDescriptor, r as ChimeraOrderConfig, s as ChimeraPrimitiveComparator, t as ChimeraKeyFromOrderGetter, v as ChimeraFilterDescriptor, w as ChimeraSimplifiedConjunctionOperation, x as ChimeraKeyFromOperatorGetter, y as ChimeraFilterOperatorDescriptor } from "./types-CuI5yXiY.cjs";
+
+//#region ../../src/debug/types.d.ts
+type ChimeraLogLevel = "debug" | "info" | "off";
+type ChimeraDebugConfig = {
+  name?: string;
+  logs?: ChimeraLogLevel;
+  devMode?: boolean;
+};
+//#endregion
+//#region ../../src/shared/ChimeraEventEmitter/ChimeraEventEmitter.d.ts
+type ValidEventTypes = string | object;
+type EventNames<T extends ValidEventTypes> = T extends string ? T : keyof T;
+type ArgumentMap<T extends object> = { [K in keyof T]: T[K] extends ((...args: any[]) => void) ? Parameters<T[K]>[0] : T[K] extends any[] ? T[K][0] : T[K] };
+type EventListener<T extends ValidEventTypes, K$1 extends EventNames<T>> = T extends string ? (arg: any) => void : (arg: ArgumentMap<Exclude<T, string | symbol>>[Extract<K$1, keyof T>]) => void;
+type EventArgs<T extends ValidEventTypes, K$1 extends EventNames<T>> = Parameters<EventListener<T, K$1>>[0];
+type EventRecord<TTEventTypes extends ValidEventTypes, TEventNames extends EventNames<TTEventTypes>> = {
+  fn: EventListener<TTEventTypes, TEventNames>;
+  once: boolean;
+};
+type EventRecordMap<T extends ValidEventTypes> = { [K in EventNames<T>]?: EventRecord<T, K> | EventRecord<T, K>[] };
+declare class ChimeraEventEmitter<TEventTypes$1 extends ValidEventTypes = string> {
+  #private;
+  _events: EventRecordMap<TEventTypes$1>;
+  _eventsCount: number;
+  constructor();
+  eventNames(): EventNames<TEventTypes$1>[];
+  listeners<T extends EventNames<TEventTypes$1>>(event: T): EventListener<TEventTypes$1, T>[];
+  listenerCount(event: EventNames<TEventTypes$1>): number;
+  removeListener<T extends EventNames<TEventTypes$1>>(event: T, fn?: EventListener<TEventTypes$1, T>, once?: boolean): this;
+  emit<T extends EventNames<TEventTypes$1>>(event: T, arg?: EventArgs<TEventTypes$1, T>): boolean;
+  on<T extends EventNames<TEventTypes$1>>(event: T, fn: EventListener<TEventTypes$1, T>): this;
+  once<T extends EventNames<TEventTypes$1>>(event: T, fn: EventListener<TEventTypes$1, T>): this;
+  removeAllListeners(event?: EventNames<TEventTypes$1>): this;
+  off: <T extends EventNames<TEventTypes$1>>(event: T, fn?: EventListener<TEventTypes$1, T>, once?: boolean) => this;
+  addListener: <T extends EventNames<TEventTypes$1>>(event: T, fn: EventListener<TEventTypes$1, T>) => this;
+}
+type AnyChimeraEventEmitter = ChimeraEventEmitter<any>;
+type ChimeraEventEmitterEvents<TEventEmitter extends AnyChimeraEventEmitter> = TEventEmitter extends ChimeraEventEmitter<infer TEventTypes> ? { [K in EventNames<TEventTypes>]: EventListener<TEventTypes, K> } : never;
+type ChimeraEventEmitterEventNames<TEventEmitter extends AnyChimeraEventEmitter> = keyof ChimeraEventEmitterEvents<TEventEmitter>;
+//#endregion
+//#region ../../src/query/types.d.ts
+declare enum ChimeraQueryFetchingState {
+  /** Query just initialized. */
+  Initialized = "initialized",
+  /** Not used yet. */
+  Scheduled = "scheduled",
+  /** Fetching in progress. */
+  Fetching = "fetching",
+  /** Creating in progress */
+  Creating = "creating",
+  /** Updating in progress. */
+  Updating = "updating",
+  /** Deleting in progress. */
+  Deleting = "deleting",
+  /** Fetch requested after reaching the Fetched, Errored, or Prefetched states. */
+  Refetching = "refetching",
+  /** Data retrieved from existing queries without initiating a fetch. */
+  Prefetched = "prefetched",
+  /** Fetch ended successfully; data is ready for use. */
+  Fetched = "fetched",
+  /** Fetch ended with an error; no data is available. */
+  Errored = "errored",
+  /** Refetch ended with an error, but old data is still available. */
+  ReErrored = "reErrored",
+  /**
+   * Only for the item query, data is deleted, but the local value is still present,
+   * no longer allows updates, but `refetch` still works (in case of strange errors, allows recovering state)
+   */
+  Deleted = "deleted",
+  /** Only for the item query, data was actualized from an external event */
+  Actualized = "actualized",
+}
+interface ChimeraQueryFetchingStatable {
+  get state(): ChimeraQueryFetchingState;
+  get inProgress(): boolean;
+  get ready(): boolean;
+}
+/**
+ * Id getter types
+ */
+type ChimeraIdGetterFunction<TEntityName$1 extends string, TEntity> = (entity: TEntity, entityName: TEntityName$1) => ChimeraEntityId;
+type ChimeraQueryEntityIdGetter<TEntityName$1 extends string, TEntity> = keyof TEntity | ChimeraIdGetterFunction<TEntityName$1, TEntity>;
+/**
+ * Response types
+ */
+type ChimeraQueryCollectionFetcherResponse<Entity, Meta = any> = {
+  data: Entity[];
+  meta?: Meta;
+};
+type ChimeraQueryItemFetcherResponse<Entity, Meta = any> = {
+  data: Entity;
+  meta?: Meta;
+};
+type ChimeraQueryDeletionResult<Success extends boolean = boolean> = {
+  id: ChimeraEntityId;
+  success: Success;
+};
+type ChimeraQueryItemDeleteResponse<Meta = any> = {
+  result: ChimeraQueryDeletionResult;
+  meta?: Meta;
+};
+type ChimeraQueryBatchedDeleteResponse<Meta = any> = {
+  result: ChimeraQueryDeletionResult[];
+  meta?: Meta;
+};
+/**
+ * Fetcher types
+ */
+type ChimeraQueryEntityFetcherRequestParams = {
+  signal: AbortSignal;
+};
+type ChimeraQueryEntityCollectionFetcherParams<Entity, OperatorsMap extends ChimeraOperatorMap, Meta = any> = {
+  order: ChimeraSimplifiedOrderDescriptor<keyof Entity & string>[] | null;
+  filter: ChimeraSimplifiedFilter<OperatorsMap, keyof Entity & string> | null;
+  meta: Meta;
+};
+type ChimeraQueryEntityItemFetcherParams<Entity, Meta = any> = {
+  id: ChimeraEntityId;
+  meta: Meta;
+};
+type ChimeraQueryEntityCollectionFetcher<TEntityName$1 extends string, TEntity, TOperatorsMap$1 extends ChimeraOperatorMap, TMeta = any> = (params: ChimeraQueryEntityCollectionFetcherParams<TEntity, TOperatorsMap$1, TMeta>, requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryCollectionFetcherResponse<TEntity>>;
+type ChimeraQueryEntityItemFetcher<TEntityName$1 extends string, TEntity> = (params: ChimeraQueryEntityItemFetcherParams<TEntity>, requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryItemFetcherResponse<TEntity>>;
+/**
+ * Updater types
+ */
+type ChimeraQueryEntityItemUpdater<TEntityName$1 extends string, TEntity> = (updatedEntity: TEntity, requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryItemFetcherResponse<TEntity>>;
+type ChimeraQueryEntityBatchedUpdater<TEntityName$1 extends string, TEntity> = (updatedEntities: TEntity[], requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryCollectionFetcherResponse<TEntity>>;
+/**
+ * Deleter types
+ */
+type ChimeraQueryEntityItemDeleter<TEntityName$1 extends string = string> = (deleteId: ChimeraEntityId, requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryItemDeleteResponse>;
+type ChimeraQueryEntityBatchedDeleter<TEntityName$1 extends string = string> = (deletedIds: ChimeraEntityId[], requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryBatchedDeleteResponse>;
+/**
+ * Creator type
+ */
+type ChimeraQueryEntityItemCreator<TEntityName$1 extends string, TEntity> = (item: DeepPartial<TEntity>, requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryItemFetcherResponse<TEntity>>;
+type ChimeraQueryEntityBatchedCreator<TEntityName$1 extends string, TEntity> = (items: DeepPartial<TEntity>[], requestParams: ChimeraQueryEntityFetcherRequestParams, entityName: TEntityName$1) => Promise<ChimeraQueryCollectionFetcherResponse<TEntity>>;
+/**
+ * Config types
+ */
+type ChimeraQueryEntityConfig<TEntityName$1 extends string, TEntity, TOperatorsMap$1 extends ChimeraOperatorMap, TMeta = any> = {
+  name: TEntityName$1;
+  trustQuery?: boolean;
+  updateDebounceTimeout?: number;
+  idGetter: ChimeraQueryEntityIdGetter<TEntityName$1, TEntity>;
+  collectionFetcher?: ChimeraQueryEntityCollectionFetcher<TEntityName$1, TEntity, TOperatorsMap$1, TMeta>;
+  itemFetcher?: ChimeraQueryEntityItemFetcher<TEntityName$1, TEntity>;
+  itemUpdater?: ChimeraQueryEntityItemUpdater<TEntityName$1, TEntity>;
+  batchedUpdater?: ChimeraQueryEntityBatchedUpdater<TEntityName$1, TEntity>;
+  itemDeleter?: ChimeraQueryEntityItemDeleter<TEntityName$1>;
+  batchedDeleter?: ChimeraQueryEntityBatchedDeleter<TEntityName$1>;
+  itemCreator?: ChimeraQueryEntityItemCreator<TEntityName$1, TEntity>;
+  batchedCreator?: ChimeraQueryEntityBatchedCreator<TEntityName$1, TEntity>;
+};
+type QueryEntityConfig<TEntityName$1 extends string, TEntity, TOperatorsMap$1 extends ChimeraOperatorMap, TMeta = any> = Required<ChimeraQueryEntityConfig<TEntityName$1, TEntity, TOperatorsMap$1, TMeta>> & {
+  idGetter: ChimeraIdGetterFunction<TEntityName$1, TEntity>;
+};
+//#endregion
+//#region ../../src/query/constants.d.ts
+declare const ChimeraGetParamsSym: unique symbol;
+declare const ChimeraSetOneSym: unique symbol;
+declare const ChimeraSetManySym: unique symbol;
+declare const ChimeraDeleteOneSym: unique symbol;
+declare const ChimeraDeleteManySym: unique symbol;
+declare const ChimeraUpdateMixedSym: unique symbol;
+//#endregion
+//#region ../../src/query/ChimeraCollectionQuery.d.ts
+type ChimeraCollectionQueryEventMap<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap> = {
+  /** Once the query is initialized */
+  initialized: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+  };
+  /** Once the query data is ready (will be followed by 'update') */
+  ready: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+  };
+  /** Each time the query was updated */
+  updated: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    items: TItem$1[];
+    oldItems: TItem$1[] | null;
+  };
+  /** Each time the query was an initiator of update */
+  selfUpdated: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    items: TItem$1[];
+    oldItems: TItem$1[] | null;
+  };
+  /** Each time item created */
+  selfItemCreated: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    item: TItem$1;
+  };
+  /** Each time item added */
+  itemAdded: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    item: TItem$1;
+  };
+  /** Each time item updated */
+  itemUpdated: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    oldItem: TItem$1;
+    newItem: TItem$1;
+  };
+  /** Each time the query was an initiator of an item update */
+  selfItemUpdated: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    item: TItem$1;
+  };
+  /** Each time item deleted */
+  itemDeleted: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    item: TItem$1;
+  };
+  /** Each time the query was an initiator of item deletion */
+  selfItemDeleted: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    id: ChimeraEntityId;
+  };
+  /** Each time the fetcher produces an error */
+  error: {
+    instance: ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    error: unknown;
+  };
+};
+declare class ChimeraCollectionQuery<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap> extends ChimeraEventEmitter<ChimeraCollectionQueryEventMap<TEntityName$1, TItem$1, TOperatorsMap$1>> implements ChimeraQueryFetchingStatable {
+  #private;
+  emit(): never;
+  constructor(config: QueryEntityConfig<TEntityName$1, TItem$1, TOperatorsMap$1>, debugConfig: ChimeraDebugConfig, params: ChimeraQueryEntityCollectionFetcherParams<TItem$1, any>, existingItems: Iterable<TItem$1> | null, order: ChimeraOrderByComparator<TItem$1>, filter: ChimeraFilterChecker<TItem$1>, alreadyValid: boolean);
+  get name(): TEntityName$1;
+  get [ChimeraGetParamsSym](): ChimeraQueryEntityCollectionFetcherParams<TItem$1, TOperatorsMap$1>;
+  [ChimeraSetOneSym](item: TItem$1): void;
+  [ChimeraDeleteOneSym](id: ChimeraEntityId): void;
+  [ChimeraSetManySym](items: Iterable<TItem$1>): void;
+  [ChimeraDeleteManySym](ids: Iterable<ChimeraEntityId>): void;
+  [ChimeraUpdateMixedSym](toAdd: Iterable<TItem$1>, toDelete: Iterable<ChimeraEntityId>): void;
+  get state(): ChimeraQueryFetchingState;
+  get inProgress(): boolean;
+  get ready(): boolean;
+  get lastError(): unknown;
+  /**
+   * Wait for the current progress process to complete (both success or error)
+   */
+  get progress(): Promise<void>;
+  /**
+   * Wait for the current progress process to complete, throw an error if it fails
+   */
+  get result(): Promise<void>;
+  /** Return an item if it is ready, throw error otherwise */
+  getById(id: ChimeraEntityId): TItem$1 | undefined;
+  /** Return mutable ref to item by idx if it is ready, throw error otherwise */
+  mutableAt(idx: number): TItem$1 | undefined;
+  /** Return mutable ref to item by [id] if it is ready, throw error otherwise */
+  mutableGetById(id: ChimeraEntityId): TItem$1 | undefined;
+  /**
+   *  Trigger refetch, return existing refetch promise if already running
+   *  @param force If true cancels any running process and starts a new one
+   *  @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
+   */
+  refetch(force?: boolean): Promise<ChimeraQueryCollectionFetcherResponse<TItem$1>>;
+  /**
+   * Update item using updated copy
+   * @param newItem new item to update
+   */
+  update(newItem: TItem$1): Promise<ChimeraQueryItemFetcherResponse<TItem$1>>;
+  /**
+   * Update item using updated copy
+   * @param newItems array of items to update
+   */
+  batchedUpdate(newItems: Iterable<TItem$1>): Promise<ChimeraQueryCollectionFetcherResponse<TItem$1>>;
+  /**
+   * Delete item using its [id]
+   * @param id id of item to delete
+   */
+  delete(id: ChimeraEntityId): Promise<ChimeraQueryItemDeleteResponse>;
+  /**
+   * Delete a list of items by their [id]s
+   * @param ids array of items to delete
+   */
+  batchedDelete(ids: Iterable<ChimeraEntityId>): Promise<ChimeraQueryBatchedDeleteResponse>;
+  /**
+   * Create new item using partial data
+   * @param item partial item data to create new item
+   */
+  create(item: DeepPartial<TItem$1>): Promise<ChimeraQueryItemFetcherResponse<TItem$1>>;
+  /**
+   * Create multiple items using partial data
+   * @param items array of partial item data to create new items
+   */
+  batchedCreate(items: Iterable<DeepPartial<TItem$1>>): Promise<ChimeraQueryCollectionFetcherResponse<TItem$1>>;
+  /**
+   * Standard Array API without mutations
+   */
+  get length(): number;
+  [Symbol.iterator](): Iterator<TItem$1>;
+  at(idx: number): TItem$1 | undefined;
+  entries(): ArrayIterator<[number, TItem$1]>;
+  values(): ArrayIterator<TItem$1>;
+  keys(): ArrayIterator<number>;
+  every<S extends TItem$1>(predicate: (value: TItem$1, index: number, query: this) => value is S): this is ChimeraCollectionQuery<TEntityName$1, S, TOperatorsMap$1>;
+  every(predicate: (value: TItem$1, index: number, query: this) => unknown): boolean;
+  some(predicate: (value: TItem$1, index: number, query: this) => unknown): boolean;
+  filter<S extends TItem$1>(predicate: (value: TItem$1, index: number, query: this) => value is S): S[];
+  filter(predicate: (value: TItem$1, index: number, query: this) => boolean): TItem$1[];
+  find<S extends TItem$1>(predicate: (value: TItem$1, index: number, query: this) => value is S): S | undefined;
+  find(predicate: (value: TItem$1, index: number, query: this) => unknown): TItem$1 | undefined;
+  findIndex<S extends TItem$1>(predicate: (value: TItem$1, index: number, query: this) => value is S): number;
+  findIndex(predicate: (value: TItem$1, index: number, query: this) => boolean): number;
+  findLast<S extends TItem$1>(predicate: (value: TItem$1, index: number, query: this) => value is S): S | undefined;
+  findLast(predicate: (value: TItem$1, index: number, query: this) => boolean): TItem$1 | undefined;
+  findLastIndex<S extends TItem$1>(predicate: (value: TItem$1, index: number, query: this) => value is S): number;
+  findLastIndex(predicate: (value: TItem$1, index: number, query: this) => boolean): number;
+  forEach(cb: (value: TItem$1, index: number, query: this) => void): void;
+  includes(item: TItem$1): boolean;
+  indexOf(item: TItem$1): number;
+  map<U>(cb: (value: TItem$1, index: number, query: this) => U): U[];
+  reduce<U>(cb: (previousValue: U, currentValue: TItem$1, currentIndex: number, query: this) => U, initialValue?: U): U | undefined;
+  reduceRight<U>(cb: (previousValue: U, currentValue: TItem$1, currentIndex: number, query: this) => U, initialValue?: U): U | undefined;
+  slice(start?: number, end?: number): TItem$1[];
+  toSorted(compareFn?: (a: TItem$1, b: TItem$1) => number): TItem$1[];
+  toSpliced(start: number, deleteCount: number, ...items: TItem$1[]): TItem$1[];
+  toJSON(): TItem$1[];
+  toString(): string;
+}
+type AnyChimeraCollectionQuery = ChimeraCollectionQuery<any, any, any>;
+type ExtractedChimeraCollectionQuery<TCollectionQuery extends AnyChimeraCollectionQuery> = TCollectionQuery extends ChimeraCollectionQuery<infer TEntityName, infer TItem, infer TOperatorsMap> ? {
+  entityName: TEntityName;
+  item: TItem;
+  operatorsMap: TOperatorsMap;
+} : never;
+type ChimeraCollectionQueryName<TCollectionQuery extends AnyChimeraCollectionQuery> = ExtractedChimeraCollectionQuery<TCollectionQuery>["entityName"];
+type ChimeraCollectionQueryEntity<TCollectionQuery extends AnyChimeraCollectionQuery> = ExtractedChimeraCollectionQuery<TCollectionQuery>["item"];
+type ChimeraCollectionQueryOperatorsMap<TCollectionQuery extends AnyChimeraCollectionQuery> = ExtractedChimeraCollectionQuery<TCollectionQuery>["operatorsMap"];
+//#endregion
+//#region ../../src/shared/errors.d.ts
+declare class ChimeraError extends Error {}
+declare class ChimeraInternalError extends ChimeraError {
+  constructor(message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region ../../src/filter/errors.d.ts
+declare class ChimeraFilterError extends ChimeraError {}
+declare class ChimeraFilterOperatorError extends ChimeraFilterError {
+  constructor(operator: string, message: string);
+}
+declare class ChimeraFilterOperatorNotFoundError extends ChimeraFilterOperatorError {
+  constructor(operator: string);
+}
+//#endregion
+//#region ../../src/filter/filter.d.ts
+declare const chimeraCreateOperator: <Entity, OperatorsMap extends ChimeraOperatorMap, Op extends keyof OperatorsMap & string>(op: Op, value: ChimeraPropertyGetter<Entity, Parameters<OperatorsMap[Op]>[0]> | (KeysOfType<Entity, Parameters<OperatorsMap[Op]>[0]> & string), test: Parameters<OperatorsMap[Op]>[1]) => ChimeraFilterOperatorDescriptor<OperatorsMap, Entity, Op>;
+declare const chimeraCreateConjunction: <Entity, OperatorsMap extends ChimeraOperatorMap, Conj extends Exclude<ChimeraConjunctionType, "not"> = Exclude<ChimeraConjunctionType, "not">>(kind: Conj, operations: ChimeraConjunctionOperationDescriptor<OperatorsMap, Entity>[]) => ChimeraConjunctionDescriptor<OperatorsMap, Entity, Conj>;
+declare const chimeraCreateNot: <Entity, OperatorsMap extends ChimeraOperatorMap>(operation: ChimeraConjunctionOperationDescriptor<OperatorsMap, Entity>) => ChimeraConjunctionDescriptor<OperatorsMap, Entity, "not">;
+declare function chimeraIsConjunction(item: ChimeraConjunctionOperationDescriptor<ChimeraOperatorMap, any>): item is ChimeraConjunctionDescriptor<ChimeraOperatorMap, any>;
+declare function chimeraIsConjunction(item: ChimeraSimplifiedConjunctionOperation<ChimeraOperatorMap>): item is SimplifiedConjunction<ChimeraOperatorMap>;
+declare function chimeraIsOperator(item: ChimeraConjunctionOperationDescriptor<ChimeraOperatorMap, any>): item is ChimeraFilterOperatorDescriptor<ChimeraOperatorMap, any>;
+declare function chimeraIsOperator(item: ChimeraSimplifiedConjunctionOperation<ChimeraOperatorMap>): item is ChimeraSimplifiedOperator<ChimeraOperatorMap>;
+//#endregion
+//#region ../../src/query/ChimeraItemQuery.d.ts
+type ChimeraItemQueryEventMap<TEntityName$1 extends string, TItem$1 extends object> = {
+  /** Once the query is initialized */
+  initialized: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+  }];
+  /** Once the query data was created */
+  selfCreated: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+    item: TItem$1;
+  }];
+  /** Once the query data is ready (will be followed by 'update') */
+  ready: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+  }];
+  /** Each time the query was updated */
+  updated: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+    item: TItem$1;
+    oldItem: TItem$1 | null;
+  }];
+  /** Each time the query was an initiator of update */
+  selfUpdated: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+    item: TItem$1;
+    oldItem: TItem$1 | null;
+  }];
+  /** Once the query data was deleted */
+  deleted: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+    id: ChimeraEntityId;
+  }];
+  /** Once the query was an initiator of deletion */
+  selfDeleted: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+    id: ChimeraEntityId;
+  }];
+  /** Each time the fetcher produces an error */
+  error: [{
+    instance: ChimeraItemQuery<TEntityName$1, TItem$1>;
+    error: unknown;
+  }];
+};
+declare class ChimeraItemQuery<TEntityName$1 extends string, TItem$1 extends object> extends ChimeraEventEmitter<ChimeraItemQueryEventMap<TEntityName$1, TItem$1>> implements ChimeraQueryFetchingStatable {
+  #private;
+  emit(): never;
+  constructor(config: QueryEntityConfig<TEntityName$1, TItem$1, ChimeraOperatorMap>, debugConfig: ChimeraDebugConfig, params: ChimeraQueryEntityItemFetcherParams<TItem$1>, existingItem: TItem$1 | null, toCreateItem: DeepPartial<TItem$1> | null);
+  get name(): TEntityName$1;
+  get [ChimeraGetParamsSym](): ChimeraQueryEntityItemFetcherParams<TItem$1>;
+  [ChimeraSetOneSym](item: TItem$1): void;
+  [ChimeraDeleteOneSym](id: ChimeraEntityId): void;
+  get state(): ChimeraQueryFetchingState;
+  get inProgress(): boolean;
+  get ready(): boolean;
+  get lastError(): unknown;
+  get id(): ChimeraEntityId;
+  /** Return an item if it is ready, throw error otherwise */
+  get data(): TItem$1;
+  /** Get ref for an item that can be changed as a regular object. To send changes to updater, use <commit> method */
+  get mutable(): TItem$1;
+  get promise(): Promise<unknown> | null;
+  /**
+   * Wait for the current progress process to complete (both success or error)
+   */
+  get progress(): Promise<void>;
+  /**
+   * Wait for the current progress process to complete, throw an error if it fails
+   */
+  get result(): Promise<void>;
+  /**
+   *  Trigger refetch, return existing refetch promise if already running
+   *  @param force If true cancels any running process and starts a new one
+   *  @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
+   */
+  refetch(force?: boolean): Promise<ChimeraQueryItemFetcherResponse<TItem$1>>;
+  /**
+   * Update item using updated copy, a running update process will be cancelled
+   * @param newItem new item to replace existing
+   * @param force if true cancels any running process including fetch and delete
+   * @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
+   */
+  update(newItem: TItem$1, force?: boolean): Promise<ChimeraQueryItemFetcherResponse<TItem$1>>;
+  /**
+   * Update item using function with draft item as argument
+   * that can be used to patch item in place or return a patched value,
+   * a running update process will be cancelled
+   * @param mutator mutator function
+   * @param force if true cancels any running process including fetch and delete
+   * @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
+   */
+  mutate(mutator: (draft: TItem$1) => TItem$1, force?: boolean): Promise<ChimeraQueryItemFetcherResponse<TItem$1>>;
+  /**
+   * Commit updated value from mutable ref, a running update process will be canceled
+   * @param force if true cancels any running process including fetch and delete
+   * @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
+   */
+  commit(force?: boolean): Promise<ChimeraQueryItemFetcherResponse<TItem$1>>;
+  /**
+   * Request to delete the value.
+   * Local copy will still be available if it was present.
+   * A running delete process will be canceled
+   * @param force if true cancels any running process including fetch and update
+   * @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
+   */
+  delete(force?: boolean): Promise<ChimeraQueryItemDeleteResponse>;
+  toJSON(): TItem$1;
+  toString(): string;
+}
+type AnyChimeraItemQuery = ChimeraItemQuery<any, any>;
+type ExtractedChimeraItemQuery<TItemQuery> = TItemQuery extends ChimeraItemQuery<infer TEntityName, infer TItem> ? {
+  entityName: TEntityName;
+  item: TItem;
+} : never;
+type ChimeraItemQueryName = ExtractedChimeraItemQuery<AnyChimeraItemQuery>["entityName"];
+type ChimeraItemQueryEntity = ExtractedChimeraItemQuery<AnyChimeraItemQuery>["item"];
+//#endregion
+//#region ../../src/entity-store/types.d.ts
+type ChimeraCollectionParams<OperatorsMap extends ChimeraOperatorMap, Entity, Meta = any> = {
+  filter?: ChimeraFilterDescriptor<OperatorsMap, Entity> | null;
+  order?: ChimeraOrderPriority<Entity> | null;
+  meta?: Meta;
+};
+//#endregion
+//#region ../../src/entity-store/ChimeraEntityStore.d.ts
+type ChimeraEntityStoreEventMap<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap> = {
+  /** Once the repository is initialized */
+  initialized: {
+    instance: ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+  };
+  /** Each time item added */
+  itemAdded: [{
+    instance: ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    item: TItem$1;
+  }];
+  /** Each time many items updated */
+  updated: [{
+    instance: ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    items: TItem$1[];
+  }];
+  /** Each time item updated */
+  itemUpdated: [{
+    instance: ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    item: TItem$1;
+    oldItem: TItem$1 | null;
+  }];
+  /** Each time many items deleted */
+  deleted: [{
+    instance: ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    ids: ChimeraEntityId[];
+  }];
+  /** Each time item deleted */
+  itemDeleted: [{
+    instance: ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+    oldItem: TItem$1 | null;
+  }];
+};
+declare class ChimeraEntityStore<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap> extends ChimeraEventEmitter<ChimeraEntityStoreEventMap<TEntityName$1, TItem$1, TOperatorsMap$1>> {
+  #private;
+  emit(): never;
+  constructor(config: QueryEntityConfig<TEntityName$1, TItem$1, TOperatorsMap$1>, filterConfig: Required<ChimeraFilterConfig<TOperatorsMap$1>>, orderConfig: Required<ChimeraOrderConfig>, debugConfig: Required<ChimeraDebugConfig>);
+  get name(): TEntityName$1;
+  updateOne(TItem: TItem$1): void;
+  deleteOne(id: ChimeraEntityId): void;
+  updateMany(items: TItem$1[]): void;
+  deleteMany(ids: ChimeraEntityId[]): void;
+  updateMixed(toAdd: TItem$1[], toDelete: ChimeraEntityId[]): void;
+  createItem(TItem: DeepPartial<TItem$1>, meta?: any): ChimeraItemQuery<TEntityName$1, TItem$1>;
+  getItem(id: ChimeraEntityId, meta?: any): ChimeraItemQuery<TEntityName$1, TItem$1>;
+  getCollection(params: ChimeraCollectionParams<TOperatorsMap$1, TItem$1>): ChimeraCollectionQuery<TEntityName$1, TItem$1, TOperatorsMap$1>;
+}
+/**
+ * Creates a ChimeraEntityStore instance with populated default values
+ * @param entityConfig Entity-specific configuration (idGetter is required)
+ * @param filterConfig Optional filter configuration (defaults to chimeraDefaultFilterConfig)
+ * @param orderConfig Optional order configuration (defaults to chimeraDefaultOrderConfig)
+ * @param debugConfig Optional debug configuration (defaults to chimeraDefaultDebugConfig)
+ * @returns ChimeraEntityStore instance
+ */
+declare function createChimeraEntityStore<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap>(entityConfig: ChimeraQueryEntityConfig<TEntityName$1, TItem$1, TOperatorsMap$1>, filterConfig: Required<ChimeraFilterConfig<TOperatorsMap$1>>, orderConfig: Required<ChimeraOrderConfig>, debugConfig: Required<ChimeraDebugConfig>): ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+declare function createChimeraEntityStore<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap>(entityConfig: ChimeraQueryEntityConfig<TEntityName$1, TItem$1, TOperatorsMap$1>, filterConfig: Required<ChimeraFilterConfig<TOperatorsMap$1>>, orderConfig: Required<ChimeraOrderConfig>): ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+declare function createChimeraEntityStore<TEntityName$1 extends string, TItem$1 extends object, TOperatorsMap$1 extends ChimeraOperatorMap>(entityConfig: ChimeraQueryEntityConfig<TEntityName$1, TItem$1, TOperatorsMap$1>, filterConfig: Required<ChimeraFilterConfig<TOperatorsMap$1>>): ChimeraEntityStore<TEntityName$1, TItem$1, TOperatorsMap$1>;
+declare function createChimeraEntityStore<TEntityName$1 extends string, TItem$1 extends object>(entityConfig: ChimeraQueryEntityConfig<TEntityName$1, TItem$1, typeof chimeraDefaultFilterConfig.operators>): ChimeraEntityStore<TEntityName$1, TItem$1, typeof chimeraDefaultFilterConfig.operators>;
+type AnyChimeraEntityStore = ChimeraEntityStore<any, any, any>;
+type ExtractedChimeraEntityStore<TStore extends AnyChimeraEntityStore> = TStore extends ChimeraEntityStore<infer TEntityName, infer TItem, infer TOperatorsMap> ? {
+  entityName: TEntityName;
+  item: TItem;
+  operatorsMap: TOperatorsMap;
+} : never;
+type ChimeraEntityStoreName<TStore extends AnyChimeraEntityStore> = ExtractedChimeraEntityStore<TStore>["entityName"];
+type ChimeraEntityStoreEntity<TStore extends AnyChimeraEntityStore> = ExtractedChimeraEntityStore<TStore>["item"];
+type ChimeraEntityStoreOperatorsMap<TStore extends AnyChimeraEntityStore> = ExtractedChimeraEntityStore<TStore>["operatorsMap"];
+//#endregion
+//#region ../../src/order/errors.d.ts
+declare class ChimeraOrderError extends ChimeraError {}
+declare class ChimeraOrderTypeError extends ChimeraOrderError {}
+declare class ChimeraOrderTypeComparisonError extends ChimeraOrderTypeError {
+  constructor(a: unknown, b: unknown);
+}
+//#endregion
+//#region ../../src/order/order.d.ts
+declare const chimeraCreateOrderBy: <Entity>(key: ChimeraPropertyGetter<Entity> | (keyof Entity & string), desc?: boolean, nulls?: ChimeraOrderNulls) => ChimeraOrderDescriptor<Entity>;
+//#endregion
+//#region ../../src/query/errors.d.ts
+declare class ChimeraQueryError extends ChimeraError {
+  readonly entityName: string;
+  constructor(entityName: string, message: string, options?: ErrorOptions);
+}
+declare class ChimeraQueryIdMismatchError extends ChimeraQueryError {
+  readonly old: ChimeraEntityId;
+  readonly new: ChimeraEntityId;
+  constructor(entityName: string, oldId: ChimeraEntityId, newId: ChimeraEntityId);
+}
+declare class ChimeraQueryNotSpecifiedError extends ChimeraQueryError {
+  readonly methodName: string;
+  constructor(entityName: string, methodName: string);
+}
+declare class ChimeraQueryTrustError extends ChimeraQueryError {
+  constructor(entityName: string, description: string);
+}
+declare class ChimeraQueryTrustIdMismatchError extends ChimeraQueryTrustError {
+  readonly old: ChimeraEntityId;
+  readonly new: ChimeraEntityId;
+  constructor(entityName: string, oldId: ChimeraEntityId, newId: ChimeraEntityId);
+}
+declare class ChimeraQueryTrustFetchedCollectionError extends ChimeraQueryTrustError {
+  readonly old: unknown[];
+  readonly new: unknown[];
+  constructor(entityName: string, input: unknown[], output: unknown[]);
+}
+//#endregion
+//#region ../../src/shared/ChimeraWeakValueMap/ChimeraWeakValueMap.d.ts
+type ChimeraWeakValueMapEventMap<K$1, V extends object> = {
+  /** An item was added to the map */
+  set: {
+    key: K$1;
+    value: V;
+    instance: ChimeraWeakValueMap<K$1, V>;
+  };
+  /** An item was removed from the map */
+  delete: {
+    key: K$1;
+    value: V;
+    instance: ChimeraWeakValueMap<K$1, V>;
+  };
+  /** Weak reference was automatically collected */
+  finalize: {
+    key: K$1;
+    instance: ChimeraWeakValueMap<K$1, V>;
+  };
+  /** All items were removed from the map */
+  clear: {
+    instance: ChimeraWeakValueMap<K$1, V>;
+  };
+};
+declare class ChimeraWeakValueMap<K$1, V extends object> extends ChimeraEventEmitter<ChimeraWeakValueMapEventMap<K$1, V>> {
+  #private;
+  emit(): never;
+  constructor(values?: readonly (readonly [K$1, V])[] | null);
+  set(key: K$1, value: V): this;
+  delete(key: K$1): boolean;
+  has(key: K$1): boolean;
+  forEach(callbackFn: (value: V, key: K$1, map: ChimeraWeakValueMap<K$1, V>) => void, thisArg?: any): void;
+  get(key: K$1): V | undefined;
+  get size(): number;
+  entries(): IterableIterator<[K$1, V]>;
+  keys(): IterableIterator<K$1>;
+  values(): IterableIterator<V>;
+  [Symbol.iterator](): IterableIterator<[K$1, V]>;
+  clear(): void;
+  cleanup(): void;
+  get rawSize(): number;
+}
+//#endregion
+export { AnyChimeraCollectionQuery, AnyChimeraEntityStore, AnyChimeraEventEmitter, AnyChimeraItemQuery, ChimeraCollectionParams, ChimeraCollectionQuery, ChimeraCollectionQueryEntity, ChimeraCollectionQueryEventMap, ChimeraCollectionQueryName, ChimeraCollectionQueryOperatorsMap, ChimeraConjunctionDescriptor, ChimeraConjunctionOperationDescriptor, ChimeraConjunctionType, ChimeraEntityGetter, ChimeraEntityId, ChimeraEntityStore, ChimeraEntityStoreEntity, ChimeraEntityStoreEventMap, ChimeraEntityStoreName, ChimeraEntityStoreOperatorsMap, ChimeraError, ChimeraEventEmitter, ChimeraEventEmitterEventNames, ChimeraEventEmitterEvents, ChimeraFilterChecker, ChimeraFilterConfig, ChimeraFilterDescriptor, ChimeraFilterError, ChimeraFilterOperatorDescriptor, ChimeraFilterOperatorError, ChimeraFilterOperatorNotFoundError, ChimeraInternalError, ChimeraItemQuery, ChimeraItemQueryEntity, ChimeraItemQueryEventMap, ChimeraItemQueryName, ChimeraKeyFromFilterGetter, ChimeraKeyFromOperatorGetter, ChimeraKeyFromOrderGetter, ChimeraOperatorFunction, ChimeraOperatorMap, ChimeraOrderByComparator, ChimeraOrderConfig, ChimeraOrderDescriptor, ChimeraOrderError, ChimeraOrderNulls, ChimeraOrderPriority, ChimeraOrderTypeComparisonError, ChimeraOrderTypeError, ChimeraPrimitiveComparator, ChimeraPropertyGetter, ChimeraQueryBatchedDeleteResponse, ChimeraQueryCollectionFetcherResponse, ChimeraQueryDeletionResult, ChimeraQueryEntityBatchedCreator, ChimeraQueryEntityBatchedDeleter, ChimeraQueryEntityBatchedUpdater, ChimeraQueryEntityCollectionFetcher, ChimeraQueryEntityCollectionFetcherParams, ChimeraQueryEntityConfig, ChimeraQueryEntityFetcherRequestParams, ChimeraQueryEntityIdGetter, ChimeraQueryEntityItemCreator, ChimeraQueryEntityItemDeleter, ChimeraQueryEntityItemFetcher, ChimeraQueryEntityItemFetcherParams, ChimeraQueryEntityItemUpdater, ChimeraQueryError, ChimeraQueryFetchingStatable, ChimeraQueryFetchingState, ChimeraQueryIdMismatchError, ChimeraQueryItemDeleteResponse, ChimeraQueryItemFetcherResponse, ChimeraQueryNotSpecifiedError, ChimeraQueryTrustError, ChimeraQueryTrustFetchedCollectionError, ChimeraQueryTrustIdMismatchError, ChimeraSimplifiedConjunctionOperation, ChimeraSimplifiedFilter, ChimeraSimplifiedOperator, ChimeraSimplifiedOrderDescriptor, ChimeraWeakValueMap, ChimeraWeakValueMapEventMap, Constructable, KeysOfType, Nullish, chimeraCreateConjunction, chimeraCreateNot, chimeraCreateOperator, chimeraCreateOrderBy, chimeraIsConjunction, chimeraIsOperator, createChimeraEntityStore };
+//# sourceMappingURL=index.d.cts.map