@aws-amplify/datastore 5.0.1-unstable.cfbde4c.0 → 5.0.1

package/package.json

@@ -1,139 +1,135 @@
 {
-  "name": "@aws-amplify/datastore",
-  "version": "5.0.1-unstable.cfbde4c.0+cfbde4c",
-  "description": "AppSyncLocal support for aws-amplify",
-  "main": "./lib/index.js",
-  "module": "./lib-esm/index.js",
-  "typings": "./lib-esm/index.d.ts",
-  "react-native": {
-    "./lib/index": "./lib-esm/index.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "sideEffects": [
-    "./lib/datastore/datastore.js",
-    "./lib-esm/datastore/datastore.js"
-  ],
-  "scripts": {
-    "test": "npm run lint && jest -w 1 --coverage",
-    "test:size": "size-limit",
-    "build-with-test": "npm test && npm run build",
-    "build:cjs": "rimraf lib && tsc -m commonjs --outDir lib && webpack && webpack --config ./webpack.config.dev.js",
-    "build:esm": "rimraf lib-esm && tsc -m esnext --outDir lib-esm",
-    "build:cjs:watch": "rimraf lib && tsc -m commonjs --outDir lib --watch",
-    "build:esm:watch": "rimraf lib-esm && tsc -m esnext --outDir lib-esm --watch",
-    "build": "yarn clean && yarn build:esm && npm run build:cjs",
-    "clean": "npm run clean:size && rimraf lib-esm lib dist",
-    "clean:size": "rimraf dual-publish-tmp tmp*",
-    "format": "echo \"Not implemented\"  && npm run ts-coverage",
-    "lint": "tslint '{__tests__,src}/**/*.ts' && npm run ts-coverage",
-    "ts-coverage": "typescript-coverage-report -p ./tsconfig.build.json -t 92.05"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/aws-amplify/amplify-js.git"
-  },
-  "author": "Amazon Web Services",
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/aws/aws-amplify/issues"
-  },
-  "homepage": "https://aws-amplify.github.io/",
-  "files": [
-    "lib",
-    "lib-esm",
-    "src",
-    "ssr"
-  ],
-  "dependencies": {
-    "@aws-amplify/api": "6.0.1-unstable.cfbde4c.0+cfbde4c",
-    "@aws-amplify/auth": "6.0.1-unstable.cfbde4c.0+cfbde4c",
-    "buffer": "4.9.2",
-    "idb": "5.0.6",
-    "immer": "9.0.6",
-    "rxjs": "^7.8.1",
-    "ulid": "^2.3.0"
-  },
-  "peerDependencies": {
-    "@aws-amplify/core": "6.0.1-unstable.cfbde4c.0+cfbde4c"
-  },
-  "devDependencies": {
-    "@aws-amplify/core": "6.0.1-unstable.cfbde4c.0+cfbde4c",
-    "@aws-amplify/react-native": "1.0.1-unstable.cfbde4c.0+cfbde4c",
-    "@types/uuid-validate": "^0.0.1",
-    "dexie": "3.2.2",
-    "dexie-export-import": "1.0.3",
-    "fake-indexeddb": "3.0.0",
-    "graphql": "15.8.0",
-    "typescript": "5.0.2"
-  },
-  "size-limit": [
-    {
-      "name": "DataStore (top-level class)",
-      "path": "./lib-esm/index.js",
-      "import": "{ Amplify, DataStore }",
-      "limit": "65.25 kB"
-    }
-  ],
-  "jest": {
-    "globals": {
-      "ts-jest": {
-        "diagnostics": true,
-        "tsConfig": {
-          "lib": [
-            "es5",
-            "es2015",
-            "dom",
-            "esnext.asynciterable",
-            "es2019"
-          ],
-          "target": "es5",
-          "allowJs": true,
-          "esModuleInterop": true,
-          "strictNullChecks": false,
-          "types": [
-            "@types/jest"
-          ]
-        }
-      }
-    },
-    "transform": {
-      "^.+\\.(js|jsx|ts|tsx)$": "ts-jest"
-    },
-    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(tsx?|jsx?)$",
-    "testPathIgnorePatterns": [
-      "__tests__/model.ts",
-      "__tests__/schema.ts",
-      "__tests__/helpers/",
-      "__tests__/commonAdapterTests.ts"
-    ],
-    "moduleFileExtensions": [
-      "ts",
-      "tsx",
-      "js",
-      "json",
-      "jsx"
-    ],
-    "testEnvironment": "jsdom",
-    "testURL": "http://localhost/",
-    "coverageThreshold": {
-      "global": {
-        "branches": 0,
-        "functions": 0,
-        "lines": 0,
-        "statements": 0
-      }
-    },
-    "coveragePathIgnorePatterns": [
-      "/node_modules/",
-      "dist",
-      "lib",
-      "lib-esm"
-    ],
-    "setupFilesAfterEnv": [
-      "<rootDir>/jest.setup.js"
-    ]
-  },
-  "gitHead": "cfbde4c7962de77bd43ba20811b84c4d7d333b42"
+	"name": "@aws-amplify/datastore",
+	"version": "5.0.1",
+	"description": "AppSyncLocal support for aws-amplify",
+	"main": "./dist/cjs/index.js",
+	"module": "./dist/esm/index.mjs",
+	"typings": "./dist/esm/index.d.ts",
+	"react-native": "./src/index.ts",
+	"publishConfig": {
+		"access": "public"
+	},
+	"sideEffects": [
+		"./dist/cjs/datastore/datastore.js",
+		"./dist/esm/datastore/datastore.mjs"
+	],
+	"scripts": {
+		"test": "npm run lint && jest -w 1 --coverage",
+		"test:size": "size-limit",
+		"build-with-test": "npm test && npm run build",
+		"build:umd": "webpack && webpack --config ./webpack.config.dev.js",
+		"build:esm-cjs": "rollup -c rollup.config.mjs",
+		"build:cjs:watch": "rimraf dist/cjs && tsc -m commonjs --outDir dist/cjs --watch",
+		"build:esm:watch": "rimraf dist/esm && tsc -m esnext --outDir dist/esm --watch",
+		"build": "npm run clean && npm run build:esm-cjs && npm run build:umd",
+		"clean": "npm run clean:size && rimraf dist lib lib-esm",
+		"clean:size": "rimraf dual-publish-tmp tmp*",
+		"format": "echo \"Not implemented\"  && npm run ts-coverage",
+		"lint": "tslint '{__tests__,src}/**/*.ts' && npm run ts-coverage",
+		"ts-coverage": "typescript-coverage-report -p ./tsconfig.json -t 92.05"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/aws-amplify/amplify-js.git"
+	},
+	"author": "Amazon Web Services",
+	"license": "Apache-2.0",
+	"bugs": {
+		"url": "https://github.com/aws/aws-amplify/issues"
+	},
+	"homepage": "https://aws-amplify.github.io/",
+	"files": [
+		"dist/cjs",
+		"dist/esm",
+		"src"
+	],
+	"dependencies": {
+		"@aws-amplify/api": "6.0.1",
+		"buffer": "4.9.2",
+		"idb": "5.0.6",
+		"immer": "9.0.6",
+		"rxjs": "^7.8.1",
+		"ulid": "^2.3.0"
+	},
+	"peerDependencies": {
+		"@aws-amplify/core": "^6.0.0"
+	},
+	"devDependencies": {
+		"@aws-amplify/core": "6.0.1",
+		"@aws-amplify/react-native": "1.0.1",
+		"@rollup/plugin-typescript": "11.1.5",
+		"@types/uuid-validate": "^0.0.1",
+		"dexie": "3.2.2",
+		"dexie-export-import": "1.0.3",
+		"fake-indexeddb": "3.0.0",
+		"graphql": "15.8.0",
+		"rollup": "3.29.4",
+		"typescript": "5.0.2"
+	},
+	"size-limit": [
+		{
+			"name": "DataStore (top-level class)",
+			"path": "./dist/esm/index.mjs",
+			"import": "{ Amplify, DataStore }",
+			"limit": "65.25 kB"
+		}
+	],
+	"jest": {
+		"globals": {
+			"ts-jest": {
+				"diagnostics": true,
+				"tsConfig": {
+					"lib": [
+						"es5",
+						"es2015",
+						"dom",
+						"esnext.asynciterable",
+						"es2019"
+					],
+					"target": "es5",
+					"allowJs": true,
+					"esModuleInterop": true,
+					"strictNullChecks": false,
+					"types": [
+						"@types/jest"
+					]
+				}
+			}
+		},
+		"transform": {
+			"^.+\\.(js|jsx|ts|tsx)$": "ts-jest"
+		},
+		"testRegex": "(/__tests__/.*|\\.(test|spec))\\.(tsx?|jsx?)$",
+		"testPathIgnorePatterns": [
+			"__tests__/model.ts",
+			"__tests__/schema.ts",
+			"__tests__/helpers/",
+			"__tests__/commonAdapterTests.ts"
+		],
+		"moduleFileExtensions": [
+			"ts",
+			"tsx",
+			"js",
+			"json",
+			"jsx"
+		],
+		"testEnvironment": "jsdom",
+		"testURL": "http://localhost/",
+		"coverageThreshold": {
+			"global": {
+				"branches": 0,
+				"functions": 0,
+				"lines": 0,
+				"statements": 0
+			}
+		},
+		"coveragePathIgnorePatterns": [
+			"/node_modules/",
+			"dist"
+		],
+		"setupFilesAfterEnv": [
+			"<rootDir>/jest.setup.js"
+		]
+	},
+	"gitHead": "f1408db3f570c4a18ada40cecbe7e68a0b31f1fe"
 }

package/lib/authModeStrategies/defaultAuthStrategy.d.ts

@@ -1,2 +0,0 @@
-import { AuthModeStrategy } from '../types';
-export declare const defaultAuthStrategy: AuthModeStrategy;

package/lib/authModeStrategies/index.d.ts

@@ -1,2 +0,0 @@
-export { defaultAuthStrategy } from './defaultAuthStrategy';
-export { multiAuthStrategy } from './multiAuthStrategy';

package/lib/authModeStrategies/multiAuthStrategy.d.ts

@@ -1,13 +0,0 @@
-import { AuthModeStrategy, AmplifyContext } from '../types';
-/**
- * Returns an array of auth modes to try based on the schema, model, and
- * authenticated user (or lack thereof). Rules are sourced from `getAuthRules`
- * and returned in the order they ought to be attempted.
- *
- * @see sortAuthRulesWithPriority
- * @see getAuthRules
- *
- * @param param0 The `{schema, modelName}` to inspect.
- * @returns A sorted array of auth modes to attempt.
- */
-export declare const multiAuthStrategy: (amplifyContext: AmplifyContext) => AuthModeStrategy;

package/lib/datastore/datastore.d.ts

@@ -1,231 +0,0 @@
-import { Observable } from 'rxjs';
-import { PredicateAll } from '../predicates';
-import { ConflictHandler, DataStoreConfig, ProducerPaginationInput, PersistentModel, PersistentModelConstructor, Schema, SubscriptionMessage, DataStoreSnapshot, TypeConstructorMap, ErrorHandler, ObserveQueryOptions, PersistentModelMetaData, IdentifierFieldOrIdentifierObject, RecursiveModelPredicateExtender, ModelPredicateExtender } from '../types';
-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: PersistentModel) => ModelAttachment;
-declare const initSchema: (userSchema: Schema) => TypeConstructorMap;
-/**
- * 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;
-/**
- * An eventually loaded related model instance.
- */
-export declare class AsyncItem<T> extends Promise<T> {
-}
-/**
- * A collection of related model instances.
- *
- * This collection can be async-iterated or turned directly into an array using `toArray()`.
- */
-export declare class AsyncCollection<T> implements AsyncIterable<T> {
-    private values;
-    constructor(values: Array<any> | Promise<Array<any>>);
-    /**
-     * Facilitates async iteration.
-     *
-     * ```ts
-     * for await (const item of collection) {
-     *   handle(item)
-     * }
-     * ```
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of
-     */
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-    /**
-     * Turns the collection into an array, up to the amount specified in `max` param.
-     *
-     * ```ts
-     * const all = await collection.toArray();
-     * const first100 = await collection.toArray({max: 100});
-     * ```
-     */
-    toArray({ max, }?: {
-        max?: number;
-    }): Promise<T[]>;
-}
-declare class DataStore {
-    private InternalAPI;
-    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.
-     * 2. Loads the schema and records metadata.
-     * 3. 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 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: keyof import("./types").PredicateGroups<T_2>, 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,100 +0,0 @@
-import { ModelPredicate, PersistentModel, PredicatesGroup, SchemaModel } from '../types';
-export { ModelSortPredicateCreator } from './sort';
-export declare function isPredicatesAll(predicate: any): predicate is typeof PredicateAll;
-/**
- * The valid comparison operators that can be used as keys in a predicate comparison object.
- */
-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 {
-    /**
-     * Map of storage predicates (key objects) to storage predicate AST's.
-     */
-    private static predicateGroupsMap;
-    /**
-     * Determines whether the given storage predicate (lookup key) is a predicate
-     * key that DataStore recognizes.
-     *
-     * @param predicate The storage predicate (lookup key) to test.
-     */
-    static isValidPredicate<T extends PersistentModel>(predicate: any): predicate is ModelPredicate<T>;
-    /**
-     * Looks for the storage predicate AST that corresponds to a given storage
-     * predicate key.
-     *
-     * The key must have been created internally by a DataStore utility
-     * method, such as `ModelPredicate.createFromAST()`.
-     *
-     * @param predicate The predicate reference to look up.
-     * @param throwOnInvalid Whether to throw an exception if the predicate
-     * isn't a valid DataStore predicate.
-     */
-    static getPredicates<T extends PersistentModel>(predicate: ModelPredicate<T>, throwOnInvalid?: boolean): PredicatesGroup<any>;
-    /**
-     * using the PK values from the given `model` (which can be a partial of T
-     * Creates a predicate that matches an instance described by `modelDefinition`
-     * that contains only PK field values.)
-     *
-     * @param modelDefinition The model definition to create a predicate for.
-     * @param model The model instance to extract value equalities from.
-     */
-    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>;
-    /**
-     * Accepts a GraphQL style filter predicate tree and transforms it into an
-     * AST that can be used for a storage adapter predicate. Example input:
-     *
-     * ```js
-     * {
-     * 	and: [
-     * 		{ name: { eq: "Bob Jones" } },
-     * 		{ age: { between: [32, 64] } },
-     * 		{ not: {
-     * 			or: [
-     * 				{ favoriteFood: { eq: 'pizza' } },
-     * 				{ favoriteFood: { eq: 'tacos' } },
-     * 			]
-     * 		}}
-     * 	]
-     * }
-     * ```
-     *
-     * @param gql GraphQL style filter node.
-     */
-    static transformGraphQLFilterNodeToPredicateAST(gql: any): any;
-    /**
-     * Accepts a GraphQL style filter predicate tree and transforms it into a predicate
-     * that storage adapters understand. Example input:
-     *
-     * ```js
-     * {
-     * 	and: [
-     * 		{ name: { eq: "Bob Jones" } },
-     * 		{ age: { between: [32, 64] } },
-     * 		{ not: {
-     * 			or: [
-     * 				{ favoriteFood: { eq: 'pizza' } },
-     * 				{ favoriteFood: { eq: 'tacos' } },
-     * 			]
-     * 		}}
-     * 	]
-     * }
-     * ```
-     *
-     * @param modelDefinition The model that the AST/predicate must be compatible with.
-     * @param ast The graphQL style AST that should specify conditions for `modelDefinition`.
-     */
-    static createFromAST<T extends PersistentModel>(modelDefinition: SchemaModel, ast: any): ModelPredicate<T>;
-}