supabase-strict-check 0.1.0

package/dist/utils/ast.js

@@ -0,0 +1,335 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loc = loc;
+exports.propName = propName;
+exports.unwrapExpr = unwrapExpr;
+exports.evalString = evalString;
+exports.evalStrings = evalStrings;
+exports.stringish = stringish;
+exports.bindingHasIdent = bindingHasIdent;
+exports.enclosingParam = enclosingParam;
+exports.isParameterIdentifier = isParameterIdentifier;
+exports.callReceiver = callReceiver;
+exports.isArrayFrom = isArrayFrom;
+exports.chainProps = chainProps;
+exports.collectChain = collectChain;
+exports.chainRoot = chainRoot;
+exports.isChainTail = isChainTail;
+exports.assignedName = assignedName;
+exports.objectLiteral = objectLiteral;
+exports.objectKeys = objectKeys;
+exports.optionString = optionString;
+exports.literalValue = literalValue;
+const typescript_1 = __importDefault(require("typescript"));
+const program_1 = require("../lib/program");
+const paths_1 = require("./paths");
+function loc(sf, node) {
+    const { line, character } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+    return { line: line + 1, column: character + 1 };
+}
+function propName(name) {
+    if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
+function unwrapExpr(expr) {
+    let current = expr;
+    for (;;) {
+        if (typescript_1.default.isParenthesizedExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (typescript_1.default.isAsExpression(current) || typescript_1.default.isTypeAssertionExpression(current) || typescript_1.default.isSatisfiesExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (typescript_1.default.isNonNullExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        return current;
+    }
+}
+function evalString(expr, consts, opts) {
+    const node = unwrapExpr(expr);
+    if (typescript_1.default.isStringLiteral(node) || typescript_1.default.isNoSubstitutionTemplateLiteral(node)) {
+        return node.text;
+    }
+    if (typescript_1.default.isBinaryExpression(node) && node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+        const left = evalString(node.left, consts, opts);
+        const right = evalString(node.right, consts, opts);
+        if (left != null && right != null)
+            return left + right;
+        return null;
+    }
+    if (typescript_1.default.isTemplateExpression(node)) {
+        let out = node.head.text;
+        for (const span of node.templateSpans) {
+            const inner = evalString(span.expression, consts, opts);
+            if (inner == null)
+                return null;
+            out += inner + span.literal.text;
+        }
+        return out;
+    }
+    if (typescript_1.default.isIdentifier(node)) {
+        if (opts?.subst?.has(node.text))
+            return opts.subst.get(node.text) ?? null;
+        if (consts.has(node.text))
+            return consts.get(node.text) ?? null;
+        if (opts?.checker) {
+            const lits = (0, program_1.stringLiteralsFromType)(opts.checker.getTypeAtLocation(node));
+            if (lits?.length === 1)
+                return lits[0];
+        }
+        return null;
+    }
+    if (opts?.checker) {
+        const lits = (0, program_1.stringLiteralsFromType)(opts.checker.getTypeAtLocation(node));
+        if (lits?.length === 1)
+            return lits[0];
+    }
+    return null;
+}
+/** All string-literal possibilities (unions / `a ? "id" : "slug"`). */
+function evalStrings(expr, consts, opts) {
+    const one = evalString(expr, consts, opts);
+    if (one != null)
+        return [one];
+    const node = unwrapExpr(expr);
+    if (typescript_1.default.isConditionalExpression(node)) {
+        const left = evalStrings(node.whenTrue, consts, opts);
+        const right = evalStrings(node.whenFalse, consts, opts);
+        if (left && right)
+            return [...left, ...right];
+    }
+    if (opts?.checker) {
+        return (0, program_1.stringLiteralsFromType)(opts.checker.getTypeAtLocation(node));
+    }
+    return null;
+}
+function stringish(expr, consts, opts) {
+    const complete = evalString(expr, consts, opts);
+    if (complete != null)
+        return { text: complete, complete: true };
+    const node = unwrapExpr(expr);
+    if (typescript_1.default.isTemplateExpression(node)) {
+        let out = node.head.text;
+        for (const span of node.templateSpans) {
+            const inner = evalString(span.expression, consts, opts);
+            out += (inner ?? "") + span.literal.text;
+        }
+        return { text: out, complete: false };
+    }
+    if (typescript_1.default.isBinaryExpression(node) && node.operatorToken.kind === typescript_1.default.SyntaxKind.PlusToken) {
+        const left = stringish(node.left, consts, opts);
+        const right = stringish(node.right, consts, opts);
+        if (!left || !right)
+            return null;
+        return { text: left.text + right.text, complete: left.complete && right.complete };
+    }
+    return null;
+}
+function bindingHasIdent(name, ident) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text === ident;
+    if (typescript_1.default.isObjectBindingPattern(name) || typescript_1.default.isArrayBindingPattern(name)) {
+        return name.elements.some((el) => {
+            if (typescript_1.default.isOmittedExpression(el))
+                return false;
+            return bindingHasIdent(el.name, ident);
+        });
+    }
+    return false;
+}
+function enclosingParam(ident) {
+    let current = ident.parent;
+    while (current) {
+        if (typescript_1.default.isFunctionLike(current) && "body" in current) {
+            const fn = current;
+            const index = fn.parameters.findIndex((p) => bindingHasIdent(p.name, ident.text));
+            if (index >= 0)
+                return { fn, index };
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function isParameterIdentifier(ident) {
+    return enclosingParam(ident) != null;
+}
+function callReceiver(call) {
+    if (typescript_1.default.isPropertyAccessExpression(call.expression))
+        return call.expression.expression;
+    if (typescript_1.default.isIdentifier(call.expression))
+        return call.expression;
+    return undefined;
+}
+function isArrayFrom(fromCall) {
+    const receiver = callReceiver(fromCall.node);
+    return Boolean(receiver && typescript_1.default.isIdentifier(receiver) && receiver.text === "Array");
+}
+function chainProps(expr) {
+    const names = [];
+    let current = expr;
+    while (current) {
+        if (typescript_1.default.isCallExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (typescript_1.default.isPropertyAccessExpression(current)) {
+            names.push(current.name.text);
+            current = current.expression;
+            continue;
+        }
+        if (typescript_1.default.isIdentifier(current)) {
+            names.push(current.text);
+            break;
+        }
+        if (typescript_1.default.isParenthesizedExpression(current) || typescript_1.default.isAsExpression(current) || typescript_1.default.isNonNullExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        break;
+    }
+    return names;
+}
+function collectChain(tail) {
+    const methods = [];
+    let current = tail;
+    while (current && typescript_1.default.isCallExpression(current)) {
+        if (typescript_1.default.isPropertyAccessExpression(current.expression)) {
+            const name = current.expression.name.text;
+            if (!paths_1.QUERY_METHODS.has(name))
+                break;
+            methods.push({
+                name,
+                args: [...current.arguments],
+                node: current,
+            });
+            current = current.expression.expression;
+            continue;
+        }
+        break;
+    }
+    methods.reverse();
+    return methods;
+}
+function chainRoot(tail) {
+    let current = tail;
+    while (current && typescript_1.default.isCallExpression(current)) {
+        if (typescript_1.default.isPropertyAccessExpression(current.expression)) {
+            const name = current.expression.name.text;
+            if (!paths_1.QUERY_METHODS.has(name))
+                break;
+            current = current.expression.expression;
+            continue;
+        }
+        break;
+    }
+    return current ? unwrapExpr(current) : undefined;
+}
+function isChainTail(node) {
+    const parent = node.parent;
+    if (typescript_1.default.isPropertyAccessExpression(parent)
+        && typescript_1.default.isCallExpression(parent.parent)
+        && parent.parent.expression === parent
+        && paths_1.QUERY_METHODS.has(parent.name.text)) {
+        return false;
+    }
+    return true;
+}
+function assignedName(tail) {
+    let current = tail;
+    while (typescript_1.default.isAsExpression(current.parent)
+        || typescript_1.default.isParenthesizedExpression(current.parent)
+        || typescript_1.default.isSatisfiesExpression(current.parent)
+        || typescript_1.default.isNonNullExpression(current.parent)
+        || typescript_1.default.isAwaitExpression(current.parent)) {
+        current = current.parent;
+    }
+    const parent = current.parent;
+    if (typescript_1.default.isVariableDeclaration(parent) && typescript_1.default.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    if (typescript_1.default.isBinaryExpression(parent)
+        && parent.operatorToken.kind === typescript_1.default.SyntaxKind.EqualsToken
+        && typescript_1.default.isIdentifier(parent.left)) {
+        return parent.left.text;
+    }
+    return null;
+}
+function objectLiteral(expr) {
+    if (!expr)
+        return null;
+    const node = unwrapExpr(expr);
+    return typescript_1.default.isObjectLiteralExpression(node) ? node : null;
+}
+function objectKeys(expr) {
+    const obj = objectLiteral(expr);
+    if (!obj) {
+        const node = expr ? unwrapExpr(expr) : null;
+        if (node && typescript_1.default.isArrayLiteralExpression(node)) {
+            const keys = new Set();
+            let hasSpread = false;
+            let anyObj = false;
+            for (const el of node.elements) {
+                const parsed = objectKeys(el);
+                if (!parsed)
+                    continue;
+                anyObj = true;
+                parsed.keys.forEach((k) => keys.add(k));
+                hasSpread = hasSpread || parsed.hasSpread;
+            }
+            return anyObj ? { keys: [...keys], hasSpread } : null;
+        }
+        return null;
+    }
+    const keys = [];
+    let hasSpread = false;
+    for (const prop of obj.properties) {
+        if (typescript_1.default.isSpreadAssignment(prop)) {
+            hasSpread = true;
+            continue;
+        }
+        if (typescript_1.default.isPropertyAssignment(prop) || typescript_1.default.isShorthandPropertyAssignment(prop)) {
+            const name = propName(prop.name);
+            if (name)
+                keys.push(name);
+        }
+    }
+    return { keys, hasSpread };
+}
+function optionString(args, options, consts, opts) {
+    const obj = args.length >= 2 ? objectLiteral(args[1]) : null;
+    if (!obj)
+        return null;
+    for (const prop of obj.properties) {
+        if (!typescript_1.default.isPropertyAssignment(prop))
+            continue;
+        const key = propName(prop.name);
+        if (!key || !options.includes(key))
+            continue;
+        return evalString(prop.initializer, consts, opts);
+    }
+    return null;
+}
+function literalValue(expr, consts, opts) {
+    const node = unwrapExpr(expr);
+    const str = evalString(node, consts, opts);
+    if (str != null)
+        return str;
+    if (typescript_1.default.isNumericLiteral(node))
+        return Number(node.text);
+    if (node.kind === typescript_1.default.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === typescript_1.default.SyntaxKind.NullKeyword)
+        return null;
+    return undefined;
+}

package/dist/utils/clients.d.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+export declare function factoryName(expr: ts.Expression): string | null;
+export declare function isClientFactoryCall(expr: ts.Expression): boolean;
+export declare function isSupabaseClientType(checker: ts.TypeChecker, type: ts.Type, seen?: Set<ts.Type>): boolean;
+export declare function exprLooksLikeClient(checker: ts.TypeChecker, expr: ts.Expression): boolean;
+/**
+ * Discover identifiers that hold a Supabase client: factory calls
+ * (`createClient`, `createBrowserClient`, …) and values typed as `SupabaseClient`.
+ */
+export declare function collectClientNames(program: ts.Program, checker: ts.TypeChecker): Set<string>;
+export declare function looksLikeClient(tail: ts.CallExpression, opts?: {
+    checker?: ts.TypeChecker;
+    names?: Set<string>;
+}): boolean;

package/dist/utils/clients.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factoryName = factoryName;
+exports.isClientFactoryCall = isClientFactoryCall;
+exports.isSupabaseClientType = isSupabaseClientType;
+exports.exprLooksLikeClient = exprLooksLikeClient;
+exports.collectClientNames = collectClientNames;
+exports.looksLikeClient = looksLikeClient;
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("./ast");
+const paths_1 = require("./paths");
+/** Official / common factories that return a Supabase client. */
+const CLIENT_FACTORIES = new Set([
+    "createClient",
+    "createBrowserClient",
+    "createServerClient",
+    "createTypedClient",
+    "createServerComponentClient",
+    "createClientComponentClient",
+    "createRouteHandlerClient",
+    "createMiddlewareClient",
+    "createServiceRoleClient",
+]);
+const CLIENT_TYPE_NAME = /SupabaseClient/;
+function factoryName(expr) {
+    const node = (0, ast_1.unwrapExpr)(expr);
+    if (!typescript_1.default.isCallExpression(node))
+        return null;
+    const callee = (0, ast_1.unwrapExpr)(node.expression);
+    if (typescript_1.default.isIdentifier(callee))
+        return callee.text;
+    if (typescript_1.default.isPropertyAccessExpression(callee))
+        return callee.name.text;
+    return null;
+}
+function isClientFactoryCall(expr) {
+    const name = factoryName(expr);
+    return name != null && CLIENT_FACTORIES.has(name);
+}
+function isSupabaseClientType(checker, type, seen = new Set()) {
+    if (seen.has(type))
+        return false;
+    seen.add(type);
+    if (type.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown | typescript_1.default.TypeFlags.Never | typescript_1.default.TypeFlags.Null | typescript_1.default.TypeFlags.Undefined)) {
+        return false;
+    }
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((t) => isSupabaseClientType(checker, t, seen));
+    }
+    const apparent = checker.getApparentType(type);
+    if (apparent !== type && isSupabaseClientType(checker, apparent, seen))
+        return true;
+    const symbolName = type.aliasSymbol?.getName() ?? type.getSymbol()?.getName() ?? "";
+    if (CLIENT_TYPE_NAME.test(symbolName))
+        return true;
+    const props = new Set(apparent.getProperties().map((p) => p.getName()));
+    return props.has("from") && (props.has("rpc") || (props.has("schema") && props.has("auth")));
+}
+function exprLooksLikeClient(checker, expr) {
+    if (isClientFactoryCall(expr))
+        return true;
+    return isSupabaseClientType(checker, checker.getTypeAtLocation(expr));
+}
+function bindingName(name) {
+    if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name))
+        return name.text;
+    return null;
+}
+function shouldKeepName(name) {
+    return !paths_1.QUERY_METHODS.has(name) && !paths_1.SKIP_CHAIN_PROPS.has(name) && name !== "from";
+}
+/**
+ * Discover identifiers that hold a Supabase client: factory calls
+ * (`createClient`, `createBrowserClient`, …) and values typed as `SupabaseClient`.
+ */
+function collectClientNames(program, checker) {
+    const names = new Set();
+    const add = (name) => {
+        if (name && shouldKeepName(name))
+            names.add(name);
+    };
+    const consider = (name, node, init) => {
+        if (!name)
+            return;
+        if (init && isClientFactoryCall(init)) {
+            add(name);
+            return;
+        }
+        if (isSupabaseClientType(checker, checker.getTypeAtLocation(node)))
+            add(name);
+    };
+    for (const sf of program.getSourceFiles()) {
+        if (sf.isDeclarationFile || sf.fileName.includes("node_modules"))
+            continue;
+        const visit = (node) => {
+            if (typescript_1.default.isVariableDeclaration(node) && typescript_1.default.isIdentifier(node.name)) {
+                consider(node.name.text, node.name, node.initializer);
+            }
+            else if (typescript_1.default.isPropertyAssignment(node)) {
+                consider(bindingName(node.name), node.name, node.initializer);
+            }
+            else if (typescript_1.default.isShorthandPropertyAssignment(node)) {
+                consider(node.name.text, node.name);
+            }
+            else if (typescript_1.default.isImportSpecifier(node)) {
+                consider(node.name.text, node.name);
+            }
+            else if (typescript_1.default.isFunctionDeclaration(node) && node.name) {
+                const sig = checker.getTypeAtLocation(node);
+                const ret = sig.getCallSignatures()[0]?.getReturnType();
+                if (ret && isSupabaseClientType(checker, ret))
+                    add(node.name.text);
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    return names;
+}
+function looksLikeClient(tail, opts) {
+    const props = (0, ast_1.chainProps)(tail.expression);
+    if (props.some((n) => CLIENT_FACTORIES.has(n)))
+        return true;
+    if (opts?.names && props.some((n) => opts.names.has(n)))
+        return true;
+    if (opts?.checker) {
+        const root = (0, ast_1.chainRoot)(tail);
+        if (root && exprLooksLikeClient(opts.checker, root))
+            return true;
+    }
+    return false;
+}

package/dist/utils/files.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+export declare function collectSourceFiles(root: string, typesFile: string): string[];
+/** Module-level `const X = "..."`, including re-exports via named imports. */
+export declare function loadImportedConsts(files: string[], srcDir: string): Map<string, Map<string, string>>;
+export declare function fileConsts(sf: ts.SourceFile, imported: Map<string, Map<string, string>>): Map<string, string>;
+export declare function relPath(file: string, from?: string): string;

package/dist/utils/files.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSourceFiles = collectSourceFiles;
+exports.loadImportedConsts = loadImportedConsts;
+exports.fileConsts = fileConsts;
+exports.relPath = relPath;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const ast_1 = require("./ast");
+function collectSourceFiles(root, typesFile) {
+    const files = [];
+    const walk = (dir) => {
+        if (!node_fs_1.default.existsSync(dir))
+            return;
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const full = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "node_modules" || entry.name === "dist")
+                    continue;
+                walk(full);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".ts") && !entry.name.endsWith(".d.ts")) {
+                files.push(full);
+            }
+        }
+    };
+    walk(root);
+    return files.filter((f) => node_path_1.default.resolve(f) !== node_path_1.default.resolve(typesFile));
+}
+function moduleStringConsts(sf) {
+    const map = new Map();
+    for (const stmt of sf.statements) {
+        if (!typescript_1.default.isVariableStatement(stmt))
+            continue;
+        for (const decl of stmt.declarationList.declarations) {
+            if (!typescript_1.default.isIdentifier(decl.name) || !decl.initializer)
+                continue;
+            const node = (0, ast_1.unwrapExpr)(decl.initializer);
+            if (typescript_1.default.isStringLiteral(node) || typescript_1.default.isNoSubstitutionTemplateLiteral(node)) {
+                map.set(decl.name.text, node.text);
+            }
+        }
+    }
+    return map;
+}
+function resolveImport(fromFile, spec, srcDir) {
+    if (spec.startsWith("@/")) {
+        spec = node_path_1.default.join(srcDir, spec.slice(2));
+    }
+    else if (spec.startsWith(".")) {
+        spec = node_path_1.default.resolve(node_path_1.default.dirname(fromFile), spec);
+    }
+    else {
+        return null;
+    }
+    const candidates = [
+        spec,
+        spec + ".ts",
+        node_path_1.default.join(spec, "index.ts"),
+    ];
+    for (const c of candidates) {
+        if (node_fs_1.default.existsSync(c) && node_fs_1.default.statSync(c).isFile())
+            return c;
+    }
+    return null;
+}
+/** Module-level `const X = "..."`, including re-exports via named imports. */
+function loadImportedConsts(files, srcDir) {
+    const parsed = new Map();
+    const local = new Map();
+    for (const file of files) {
+        const sf = typescript_1.default.createSourceFile(file, node_fs_1.default.readFileSync(file, "utf8"), typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+        parsed.set(file, sf);
+        local.set(file, moduleStringConsts(sf));
+    }
+    const resolved = new Map();
+    const visiting = new Set();
+    const resolveFile = (file) => {
+        const hit = resolved.get(file);
+        if (hit)
+            return hit;
+        if (visiting.has(file))
+            return local.get(file) ?? new Map();
+        visiting.add(file);
+        const out = new Map(local.get(file) ?? []);
+        const sf = parsed.get(file);
+        if (sf) {
+            for (const stmt of sf.statements) {
+                if (!typescript_1.default.isImportDeclaration(stmt) || !stmt.importClause)
+                    continue;
+                if (!typescript_1.default.isStringLiteral(stmt.moduleSpecifier))
+                    continue;
+                const target = resolveImport(file, stmt.moduleSpecifier.text, srcDir);
+                if (!target)
+                    continue;
+                const exported = resolveFile(target);
+                const named = stmt.importClause.namedBindings;
+                if (named && typescript_1.default.isNamedImports(named)) {
+                    for (const el of named.elements) {
+                        const imported = (el.propertyName ?? el.name).text;
+                        const localName = el.name.text;
+                        const value = exported.get(imported);
+                        if (value != null)
+                            out.set(localName, value);
+                    }
+                }
+            }
+        }
+        resolved.set(file, out);
+        visiting.delete(file);
+        return out;
+    };
+    for (const file of files)
+        resolveFile(file);
+    return resolved;
+}
+function fileConsts(sf, imported) {
+    const map = new Map(imported.get(node_path_1.default.resolve(sf.fileName)) ?? []);
+    const counts = new Map();
+    const visit = (node) => {
+        if (typescript_1.default.isVariableDeclaration(node) && typescript_1.default.isIdentifier(node.name) && node.initializer) {
+            const init = (0, ast_1.unwrapExpr)(node.initializer);
+            if (typescript_1.default.isStringLiteral(init) || typescript_1.default.isNoSubstitutionTemplateLiteral(init)) {
+                const name = node.name.text;
+                counts.set(name, (counts.get(name) ?? 0) + 1);
+                map.set(name, init.text);
+            }
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(sf);
+    for (const [name, count] of counts) {
+        if (count > 1)
+            map.delete(name);
+    }
+    return map;
+}
+function relPath(file, from = process.cwd()) {
+    return node_path_1.default.relative(from, file);
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_SCHEMA = "public";
+export declare const JOIN_HINTS: Set<string>;
+export declare const AGGREGATES: Set<string>;
+export declare const FILTER_COLUMN_METHODS: Set<string>;
+export declare const SKIP_CHAIN_PROPS: Set<string>;
+export declare const QUERY_METHODS: Set<string>;