@aws-amplify/datastore 3.14.5-unstable.4 → 3.14.5

package/lib/datastore/datastore.d.ts

@@ -1,207 +0,0 @@
-import Observable from 'zen-observable-ts';
-import { PredicateAll } from '../predicates';
-import { ConflictHandler, DataStoreConfig, NonModelTypeConstructor, ProducerPaginationInput, PersistentModel, PersistentModelConstructor, Schema, SubscriptionMessage, DataStoreSnapshot, TypeConstructorMap, ErrorHandler, ObserveQueryOptions, PersistentModelMetaData, IdentifierFieldOrIdentifierObject } from '../types';
-import { RecursiveModelPredicateExtender, ModelPredicateExtender } from '../predicates/next';
-export declare let syncClasses: TypeConstructorMap;
-/**
- * Describes whether and to what a model is attached for lazy loading purposes.
- */
-declare enum ModelAttachment {
-    /**
-     * Model doesn't lazy load from any data source.
-     *
-     * Related entity properties provided at instantiation are returned
-     * via the respective lazy interfaces when their properties are invoked.
-     */
-    Detached = "Detached",
-    /**
-     * Model lazy loads from the global DataStore.
-     */
-    DataStore = "DataStore",
-    /**
-     * Demonstrative. Not yet implemented.
-     */
-    API = "API"
-}
-/**
- * Registers a model instance against a data source (DataStore, API, or
- * Detached/None).
- *
- * The API option is demonstrative. Lazy loading against API is not yet
- * implemented.
- *
- * @param result A model instance or array of instances
- * @param attachment A ModelAttachment data source
- * @returns passes the `result` back through after attachment
- */
-export declare function attached<T extends PersistentModel | PersistentModel[]>(result: T, attachment: ModelAttachment): T;
-/**
- * Determines what source a model instance should lazy load from.
- *
- * If the instace was never explicitly registered, it is detached by default.
- *
- * @param instance A model instance
- */
-export declare const getAttachment: (instance: Readonly<Record<string, any>>) => ModelAttachment.Detached | ModelAttachment;
-declare const initSchema: (userSchema: Schema) => Record<string, PersistentModelConstructor<any> | NonModelTypeConstructor<unknown>>;
-/**
- * Constructs a model and records it with its metadata in a weakset. Allows for
- * the separate storage of core model fields and Amplify/DataStore metadata
- * fields that the customer app does not want exposed.
- *
- * @param modelConstructor The model constructor.
- * @param init Init data that would normally be passed to the constructor.
- * @returns The initialized model.
- */
-export declare type ModelInstanceCreator = typeof modelInstanceCreator;
-declare function modelInstanceCreator<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, init: Partial<T>): T;
-export declare class AsyncItem<T> extends Promise<T> {
-}
-export declare class AsyncCollection<T> implements AsyncIterable<T> {
-    private values;
-    constructor(values: Array<any> | Promise<Array<any>>);
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-    toArray({ max, }?: {
-        max?: number;
-    }): Promise<T[]>;
-}
-declare class DataStore {
-    private Auth;
-    private API;
-    private Cache;
-    private amplifyConfig;
-    private authModeStrategy;
-    private conflictHandler;
-    private errorHandler;
-    private fullSyncInterval;
-    private initialized?;
-    private initReject;
-    private initResolve;
-    private maxRecordsToSync;
-    private storage?;
-    private sync?;
-    private syncPageSize;
-    private syncExpressions;
-    private syncPredicates;
-    private sessionId?;
-    private storageAdapter;
-    private amplifyContext;
-    private connectivityMonitor?;
-    /**
-     * **IMPORTANT!**
-     *
-     * Accumulator for background things that can **and MUST** be called when
-     * DataStore stops.
-     *
-     * These jobs **MUST** be *idempotent promises* that resolve ONLY
-     * once the intended jobs are completely finished and/or otherwise destroyed
-     * and cleaned up with ZERO outstanding:
-     *
-     * 1. side effects (e.g., state changes)
-     * 1. callbacks
-     * 1. subscriptions
-     * 1. calls to storage
-     * 1. *etc.*
-     *
-     * Methods that create pending promises, subscriptions, callbacks, or any
-     * type of side effect **MUST** be registered with the manager. And, a new
-     * manager must be created after each `exit()`.
-     *
-     * Failure to comply will put DataStore into a highly unpredictable state
-     * when it needs to stop or clear -- which occurs when restarting with new
-     * sync expressions, during testing, and potentially during app code
-     * recovery handling, etc..
-     *
-     * It is up to the discretion of each disposer whether to wait for job
-     * completion or to cancel operations and issue failures *as long as the
-     * disposer returns in a reasonable amount of time.*
-     *
-     * (Reasonable = *seconds*, not minutes.)
-     */
-    private runningProcesses;
-    /**
-     * Indicates what state DataStore is in.
-     *
-     * Not [yet?] used for actual state management; but for messaging
-     * when errors occur, to help troubleshoot.
-     */
-    private state;
-    getModuleName(): string;
-    /**
-     * Builds a function to capture `BackgroundManagerNotOpenError`'s to produce friendlier,
-     * more instructive errors for customers.
-     *
-     * @param operation The name of the operation (usually a Datastore method) the customer
-     * tried to call.
-     */
-    handleAddProcError(operation: string): (err: Error) => never;
-    /**
-     * If not already done:
-     * 1. Attaches and initializes storage.
-     * 1. Loads the schema and records metadata.
-     * 1. If `this.amplifyConfig.aws_appsync_graphqlEndpoint` contains a URL,
-     * attaches a sync engine, starts it, and subscribes.
-     */
-    start: () => Promise<void>;
-    query: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, identifier: IdentifierFieldOrIdentifierObject<T, PersistentModelMetaData<T>>): Promise<T | undefined>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: RecursiveModelPredicateExtender<T> | typeof PredicateAll | null, paginationProducer?: ProducerPaginationInput<T>): Promise<T[]>;
-    };
-    save: <T extends Readonly<Record<string, any>>>(model: T, condition?: ModelPredicateExtender<T>) => Promise<T>;
-    setConflictHandler: (config: DataStoreConfig) => ConflictHandler;
-    setErrorHandler: (config: DataStoreConfig) => ErrorHandler;
-    delete: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, identifier: IdentifierFieldOrIdentifierObject<T, PersistentModelMetaData<T>>): Promise<T[]>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, condition: ModelPredicateExtender<T> | typeof PredicateAll): Promise<T[]>;
-        <T extends PersistentModel>(model: T, condition?: ModelPredicateExtender<T>): Promise<T>;
-    };
-    observe: {
-        (): Observable<SubscriptionMessage<PersistentModel>>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, identifier: string): Observable<SubscriptionMessage<T>>;
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: RecursiveModelPredicateExtender<T> | typeof PredicateAll): Observable<SubscriptionMessage<T>>;
-        <T extends PersistentModel>(model: T): Observable<SubscriptionMessage<T>>;
-    };
-    observeQuery: {
-        <T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: RecursiveModelPredicateExtender<T> | typeof PredicateAll, paginationProducer?: ObserveQueryOptions<T>): Observable<DataStoreSnapshot<T>>;
-    };
-    configure: (config?: DataStoreConfig) => void;
-    /**
-     * Clears all data from storage and removes all data, schema info, other
-     * initialization details, and then stops DataStore.
-     *
-     * That said, reinitialization is required after clearing. This can be done
-     * by explicitiliy calling `start()` or any method that implicitly starts
-     * DataStore, such as `query()`, `save()`, or `delete()`.
-     */
-    clear(): Promise<void>;
-    /**
-     * Stops all DataStore sync activities.
-     *
-     * TODO: "Waits for graceful termination of
-     * running queries and terminates subscriptions."
-     */
-    stop(this: InstanceType<typeof DataStore>): Promise<void>;
-    /**
-     * Validates given pagination input from a query and creates a pagination
-     * argument for use against the storage layer.
-     *
-     * @param modelDefinition
-     * @param paginationProducer
-     */
-    private processPagination;
-    /**
-     * Examines the configured `syncExpressions` and produces a WeakMap of
-     * SchemaModel -> predicate to use during sync.
-     */
-    private processSyncExpressions;
-    private createFromCondition;
-    private unwrapPromise;
-    private weakMapFromEntries;
-    /**
-     * A session ID to allow CMS to open databases against multiple apps.
-     * This session ID is only expected be set by AWS Amplify Studio.
-     */
-    private retrieveSessionId;
-}
-declare const instance: DataStore;
-export { DataStore as DataStoreClass, initSchema, instance as DataStore };

package/lib/index.d.ts

@@ -1,16 +0,0 @@
-export { DataStore, DataStoreClass, initSchema, ModelInstanceCreator, AsyncCollection, AsyncItem, } from './datastore/datastore';
-export { Predicates, ModelPredicateCreator, ModelSortPredicateCreator, } from './predicates';
-export { Adapter as StorageAdapter } from './storage/adapter';
-export { NAMESPACES } from './util';
-export declare const utils: {
-    USER: import("./util").NAMESPACES;
-    traverseModel: <T extends Readonly<Record<string, any>>>(srcModelName: string, instance: T, namespace: import("./types").SchemaNamespace, modelInstanceCreator: <T_1 extends Readonly<Record<string, any>>>(modelConstructor: import("./types").PersistentModelConstructor<T_1>, init: Partial<T_1>) => T_1, getModelConstructorByModelName: (namsespaceName: import("./util").NAMESPACES, modelName: string) => import("./types").PersistentModelConstructor<any>) => {
-        modelName: string;
-        item: T;
-        instance: T;
-    }[];
-    validatePredicate: <T_2 extends Readonly<Record<string, any>>>(model: T_2, groupType: "and" | "or" | "not", predicatesOrGroups: (import("./types").PredicateObject<T_2> | import("./types").PredicatesGroup<T_2>)[]) => any;
-    isNonModelConstructor: (obj: any) => obj is import("./types").NonModelTypeConstructor<any>;
-    isModelConstructor: <T_3 extends Readonly<Record<string, any>>>(obj: any) => obj is import("./types").PersistentModelConstructor<T_3>;
-};
-export * from './types';

package/lib/predicates/index.d.ts

@@ -1,30 +0,0 @@
-import { ModelPredicate, PersistentModel, PredicatesGroup, ProducerModelPredicate, SchemaModel } from '../types';
-export { ModelSortPredicateCreator } from './sort';
-export declare function isPredicatesAll(predicate: any): predicate is typeof PredicateAll;
-export declare const comparisonKeys: Set<string>;
-export declare const PredicateAll: unique symbol;
-export declare class Predicates {
-    static get ALL(): typeof PredicateAll;
-}
-export declare class ModelPredicateCreator {
-    private static predicateGroupsMap;
-    static createPredicateBuilder<T extends PersistentModel>(modelDefinition: SchemaModel): ModelPredicate<T>;
-    static isValidPredicate<T extends PersistentModel>(predicate: any): predicate is ModelPredicate<T>;
-    static getPredicates<T extends PersistentModel>(predicate: ModelPredicate<T>, throwOnInvalid?: boolean): PredicatesGroup<any>;
-    static createFromExisting<T extends PersistentModel>(modelDefinition?: SchemaModel, existing?: ProducerModelPredicate<T>): ModelPredicate<T>;
-    static createForSingleField<T extends PersistentModel>(modelDefinition: SchemaModel, fieldName: string, value: string): ModelPredicate<T>;
-    static createForPk<T extends PersistentModel>(modelDefinition: SchemaModel, model: T): ModelPredicate<T>;
-    /**
-     * Searches a `Model` table for records matching the given equalities object.
-     *
-     * This only matches against fields given in the equalities object. No other
-     * fields are tested by the predicate.
-     *
-     * @param modelDefinition The model we need a predicate for.
-     * @param flatEqualities An object holding field equalities to search for.
-     */
-    static createFromFlatEqualities<T extends PersistentModel>(modelDefinition: SchemaModel, flatEqualities: Record<string, any>): ModelPredicate<T>;
-    static createGroupFromExisting<T extends PersistentModel>(modelDefinition: SchemaModel, group: 'and' | 'or' | 'not', existingPredicates: (ProducerModelPredicate<T> | ModelPredicate<T>)[]): ModelPredicate<T>;
-    static transformGraphQLtoPredicateAST(gql: any): any;
-    static createFromAST(modelDefinition: SchemaModel, ast: any): ModelPredicate<any>;
-}

package/lib/predicates/next.d.ts

@@ -1,301 +0,0 @@
-import { Scalar, PersistentModel, ModelMeta, AllOperators, PredicateFieldType, ModelPredicate as StoragePredicate } from '../types';
-import { ExclusiveStorage as StorageAdapter } from '../storage/storage';
-declare type MatchableTypes = string | string[] | number | number[] | boolean | boolean[];
-declare type AllFieldOperators = keyof AllOperators;
-declare type NonNeverKeys<T> = {
-    [K in keyof T]: T[K] extends never ? never : K;
-}[keyof T];
-declare type WithoutNevers<T> = Pick<T, NonNeverKeys<T>>;
-/**
- * A function that accepts a RecursiveModelPrecicate<T>, which it must use to
- * return a final condition.
- *
- * This is used in `DataStore.query()`, `DataStore.observe()`, and
- * `DataStore.observeQuery()` as the second argument. E.g.,
- *
- * ```
- * DataStore.query(MyModel, model => model.field.eq('some value'))
- * ```
- *
- * More complex queries should also be supported. E.g.,
- *
- * ```
- * DataStore.query(MyModel, model => model.and(m => [
- *   m.relatedEntity.or(relative => [
- *     relative.relativeField.eq('whatever'),
- *     relative.relativeField.eq('whatever else')
- *   ]),
- *   m.myModelField.ne('something')
- * ]))
- * ```
- */
-export declare type RecursiveModelPredicateExtender<RT extends PersistentModel> = (lambda: RecursiveModelPredicate<RT>) => PredicateInternalsKey;
-export declare type RecursiveModelPredicateAggregateExtender<RT extends PersistentModel> = (lambda: RecursiveModelPredicate<RT>) => PredicateInternalsKey[];
-declare type RecursiveModelPredicateOperator<RT extends PersistentModel> = (predicates: RecursiveModelPredicateAggregateExtender<RT>) => PredicateInternalsKey;
-declare type RecursiveModelPredicateNegation<RT extends PersistentModel> = (predicate: RecursiveModelPredicateExtender<RT>) => PredicateInternalsKey;
-export declare type RecursiveModelPredicate<RT extends PersistentModel> = {
-    [K in keyof RT]-?: PredicateFieldType<RT[K]> extends PersistentModel ? RecursiveModelPredicate<PredicateFieldType<RT[K]>> : ValuePredicate<RT, RT[K]>;
-} & {
-    or: RecursiveModelPredicateOperator<RT>;
-    and: RecursiveModelPredicateOperator<RT>;
-    not: RecursiveModelPredicateNegation<RT>;
-} & PredicateInternalsKey;
-/**
- * A function that accepts a ModelPrecicate<T>, which it must use to return a
- * final condition.
- *
- * This is used as predicates in `DataStore.save()`, `DataStore.delete()`, and
- * DataStore sync expressions.
- *
- * ```
- * DataStore.save(record, model => model.field.eq('some value'))
- * ```
- *
- * Logical operators are supported. But, condtiions are related records are
- * NOT supported. E.g.,
- *
- * ```
- * DataStore.delete(record, model => model.or(m => [
- * 	m.field.eq('whatever'),
- * 	m.field.eq('whatever else')
- * ]))
- * ```
- */
-export declare type ModelPredicateExtender<RT extends PersistentModel> = (lambda: ModelPredicate<RT>) => PredicateInternalsKey;
-export declare type ModelPredicateAggregateExtender<RT extends PersistentModel> = (lambda: ModelPredicate<RT>) => PredicateInternalsKey[];
-declare type ValuePredicate<RT extends PersistentModel, MT extends MatchableTypes> = {
-    [K in AllFieldOperators]: K extends 'between' ? (inclusiveLowerBound: Scalar<MT>, inclusiveUpperBound: Scalar<MT>) => PredicateInternalsKey : (operand: Scalar<MT>) => PredicateInternalsKey;
-};
-export declare type ModelPredicate<RT extends PersistentModel> = WithoutNevers<{
-    [K in keyof RT]-?: PredicateFieldType<RT[K]> extends PersistentModel ? never : ValuePredicate<RT, RT[K]>;
-}> & {
-    or: ModelPredicateOperator<RT>;
-    and: ModelPredicateOperator<RT>;
-    not: ModelPredicateNegation<RT>;
-} & PredicateInternalsKey;
-declare type ModelPredicateOperator<RT extends PersistentModel> = (predicates: ModelPredicateAggregateExtender<RT>) => PredicateInternalsKey;
-declare type ModelPredicateNegation<RT extends PersistentModel> = (predicate: ModelPredicateExtender<RT>) => PredicateInternalsKey;
-declare type GroupOperator = 'and' | 'or' | 'not';
-declare type UntypedCondition = {
-    fetch: (storage: StorageAdapter) => Promise<Record<string, any>[]>;
-    matches: (item: Record<string, any>) => Promise<boolean>;
-    copy(extract: GroupCondition): [UntypedCondition, GroupCondition | undefined];
-    toAST(): any;
-};
-/**
- * A pointer used by DataStore internally to lookup predicate details
- * that should not be exposed on public customer interfaces.
- */
-export declare class PredicateInternalsKey {
-    private __isPredicateInternalsKeySentinel;
-}
-/**
- * Takes a key object from `registerPredicateInternals()` to fetch an internal
- * `GroupCondition` object, which can then be used to query storage or
- * test/match objects.
- *
- * This indirection exists to hide `GroupCondition` from public interfaces, since
- * `GroupCondition` contains extra methods and properties that public callers
- * should not use.
- *
- * @param key A key object previously returned by `registerPredicateInternals()`
- */
-export declare const internals: (key: any) => GroupCondition;
-/**
- * A condition that can operate against a single "primitive" field of a model or item.
- * @member field The field of *some record* to test against.
- * @member operator The equality or comparison operator to use.
- * @member operands The operands for the equality/comparison check.
- */
-export declare class FieldCondition {
-    field: string;
-    operator: string;
-    operands: string[];
-    constructor(field: string, operator: string, operands: string[]);
-    /**
-     * Creates a copy of self.
-     * @param extract Not used. Present only to fulfill the `UntypedCondition` interface.
-     * @returns A new, identitical `FieldCondition`.
-     */
-    copy(extract: GroupCondition): [FieldCondition, GroupCondition | undefined];
-    toAST(): {
-        [x: string]: {
-            [x: string]: string | string[];
-        };
-    };
-    /**
-     * Not implemented. Not needed. GroupCondition instead consumes FieldConditions and
-     * transforms them into legacy predicates. (*For now.*)
-     * @param storage N/A. If ever implemented, the storage adapter to query.
-     * @returns N/A. If ever implemented, return items from `storage` that match.
-     */
-    fetch(storage: StorageAdapter): Promise<Record<string, any>[]>;
-    /**
-     * Determins whether a given item matches the expressed condition.
-     * @param item The item to test.
-     * @returns `Promise<boolean>`, `true` if matches; `false` otherwise.
-     */
-    matches(item: Record<string, any>): Promise<boolean>;
-    /**
-     * Checks `this.operands` for compatibility with `this.operator`.
-     */
-    validate(): void;
-}
-/**
- * A set of sub-conditions to operate against a model, optionally scoped to
- * a specific field, combined with the given operator (one of `and`, `or`, or `not`).
- * @member groupId Used to distinguish between GroupCondition instances for
- * debugging and troublehsooting.
- * @member model A metadata object that tells GroupCondition what to query and how.
- * @member field The field on the model that the sub-conditions apply to.
- * @member operator How to group child conditions together.
- * @member operands The child conditions.
- */
-export declare class GroupCondition {
-    /**
-     * The `ModelMeta` of the model to query and/or filter against.
-     * Expected to contain:
-     *
-     * ```js
-     * {
-     * 	builder: ModelConstructor,
-     * 	schema: SchemaModel,
-     * 	pkField: string[]
-     * }
-     * ```
-     */
-    model: ModelMeta<any>;
-    /**
-     * If populated, this group specifices a condition on a relationship.
-     *
-     * If `field` does *not* point to a related model, that's an error. It
-     * could indicate that the `GroupCondition` was instantiated with bad
-     * data, or that the model metadata is incorrect.
-     */
-    field: string | undefined;
-    /**
-     * If a `field` is given, whether the relationship is a `HAS_ONE`,
-     * 'HAS_MANY`, or `BELONGS_TO`.
-     *
-     * TODO: Remove this and replace with derivation using
-     * `ModelRelationship.from(this.model, this.field).relationship`;
-     */
-    relationshipType: string | undefined;
-    /**
-     *
-     */
-    operator: GroupOperator;
-    /**
-     *
-     */
-    operands: UntypedCondition[];
-    groupId: string;
-    constructor(
-    /**
-     * The `ModelMeta` of the model to query and/or filter against.
-     * Expected to contain:
-     *
-     * ```js
-     * {
-     * 	builder: ModelConstructor,
-     * 	schema: SchemaModel,
-     * 	pkField: string[]
-     * }
-     * ```
-     */
-    model: ModelMeta<any>, 
-    /**
-     * If populated, this group specifices a condition on a relationship.
-     *
-     * If `field` does *not* point to a related model, that's an error. It
-     * could indicate that the `GroupCondition` was instantiated with bad
-     * data, or that the model metadata is incorrect.
-     */
-    field: string | undefined, 
-    /**
-     * If a `field` is given, whether the relationship is a `HAS_ONE`,
-     * 'HAS_MANY`, or `BELONGS_TO`.
-     *
-     * TODO: Remove this and replace with derivation using
-     * `ModelRelationship.from(this.model, this.field).relationship`;
-     */
-    relationshipType: string | undefined, 
-    /**
-     *
-     */
-    operator: GroupOperator, 
-    /**
-     *
-     */
-    operands: UntypedCondition[]);
-    /**
-     * Returns a copy of a GroupCondition, which also returns the copy of a
-     * given reference node to "extract".
-     * @param extract A node of interest. Its copy will *also* be returned if the node exists.
-     * @returns [The full copy, the copy of `extract` | undefined]
-     */
-    copy(extract: GroupCondition): [GroupCondition, GroupCondition | undefined];
-    /**
-     * Fetches matching records from a given storage adapter using legacy predicates (for now).
-     * @param storage The storage adapter this predicate will query against.
-     * @param breadcrumb For debugging/troubleshooting. A list of the `groupId`'s this
-     * GroupdCondition.fetch is nested within.
-     * @param negate Whether to match on the `NOT` of `this`.
-     * @returns An `Promise` of `any[]` from `storage` matching the child conditions.
-     */
-    fetch(storage: StorageAdapter, breadcrumb?: string[], negate?: boolean): Promise<Record<string, any>[]>;
-    /**
-     * Determines whether a single item matches the conditions of `this`.
-     * When checking the target `item`'s properties, each property will be `await`'d
-     * to ensure lazy-loading is respected where applicable.
-     * @param item The item to match against.
-     * @param ignoreFieldName Tells `match()` that the field name has already been dereferenced.
-     * (Used for iterating over children on HAS_MANY checks.)
-     * @returns A boolean (promise): `true` if matched, `false` otherwise.
-     */
-    matches(item: Record<string, any>, ignoreFieldName?: boolean): Promise<boolean>;
-    /**
-     * Tranfsorm to a AppSync GraphQL compatible AST.
-     * (Does not support filtering in nested types.)
-     */
-    toAST(): {
-        [x: string]: any[];
-    };
-    toStoragePredicate<T>(baseCondition?: StoragePredicate<T>): StoragePredicate<T>;
-}
-/**
- * Creates a "seed" predicate that can be used to build an executable condition.
- * This is used in `query()`, for example, to seed customer- E.g.,
- *
- * ```
- * const p = predicateFor({builder: modelConstructor, schema: modelSchema, pkField: string[]});
- * p.and(child => [
- *   child.field.eq('whatever'),
- *   child.childModel.childField.eq('whatever else'),
- *   child.childModel.or(child => [
- *     child.otherField.contains('x'),
- *     child.otherField.contains('y'),
- *     child.otherField.contains('z'),
- *   ])
- * ])
- * ```
- *
- * `predicateFor()` returns objecst with recursive getters. To facilitate this,
- * a `query` and `tail` can be provided to "accumulate" nested conditions.
- *
- * TODO: the sortof-immutable algorithm was originally done to support legacy style
- * predicate branching (`p => p.x.eq(value).y.eq(value)`). i'm not sure this is
- * necessary or beneficial at this point, since we decided that each field condition
- * must flly terminate a branch. is the strong mutation barrier between chain links
- * still necessary or helpful?
- *
- * @param ModelType The ModelMeta used to build child properties.
- * @param field Scopes the query branch to a field.
- * @param query A base query to build on. Omit to start a new query.
- * @param tail The point in an existing `query` to attach new conditions to.
- * @returns A ModelPredicate (builder) that customers can create queries with.
- * (As shown in function description.)
- */
-export declare function recursivePredicateFor<T extends PersistentModel>(ModelType: ModelMeta<T>, allowRecursion?: boolean, field?: string, query?: GroupCondition, tail?: GroupCondition): RecursiveModelPredicate<T> & PredicateInternalsKey;
-export declare function predicateFor<T extends PersistentModel>(ModelType: ModelMeta<T>): ModelPredicate<T> & PredicateInternalsKey;
-export {};