@dereekb/firebase 13.11.17 → 13.11.18

package/eslint/index.cjs.js

@@ -46,15 +46,15 @@
     return result;
 }
 
-function _array_like_to_array$3(arr, len) {
+function _array_like_to_array$5(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_with_holes$1(arr) {
+function _array_with_holes$2(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _iterable_to_array_limit$1(arr, i) {
+function _iterable_to_array_limit$2(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
     var _arr = [];
@@ -78,19 +78,19 @@ function _iterable_to_array_limit$1(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest$1() {
+function _non_iterable_rest$2() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _sliced_to_array$1(arr, i) {
-    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$3(arr, i) || _non_iterable_rest$1();
+function _sliced_to_array$2(arr, i) {
+    return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$5(arr, i) || _non_iterable_rest$2();
 }
-function _unsupported_iterable_to_array$3(o, minLen) {
+function _unsupported_iterable_to_array$5(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$5(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$5(o, minLen);
 }
 var TAG_LINE_REGEX = /^@([A-Za-z_]\w*)\s*(.*)$/;
 var TYPE_ANNOTATION_REGEX = /^\{([^}]*)\}\s*(.*)$/;
@@ -155,7 +155,7 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         for(var _iterator = lines.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _step_value = _sliced_to_array$1(_step.value, 2), i = _step_value[0], line = _step_value[1];
+            var _step_value = _sliced_to_array$2(_step.value, 2), i = _step_value[0], line = _step_value[1];
             if (TAG_LINE_REGEX.test(line.text)) {
                 firstTagIndex = i;
                 break;
@@ -391,30 +391,30 @@ var LINE_PREFIX_REGEX = /^(\s*\*?\s?)(.*)$/;
     };
 }
 
-function _array_like_to_array$2(arr, len) {
+function _array_like_to_array$4(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes$1(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+function _array_without_holes$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
 }
-function _iterable_to_array$1(iter) {
+function _iterable_to_array$2(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread$1() {
+function _non_iterable_spread$2() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _to_consumable_array$1(arr) {
-    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$1();
+function _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$2();
 }
-function _unsupported_iterable_to_array$2(o, minLen) {
+function _unsupported_iterable_to_array$4(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$4(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
 }
 /**
  * Module that publishes the `@dereekb/firebase` Firestore constraint factories (`where`, `orderBy`, etc.).
@@ -460,7 +460,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
  * Combined list of every Firestore constraint factory exported from `@dereekb/firebase`. Used
  * by the body-coherence rule to ensure a tagged factory body contains at least one constraint
  * call of any kind (index-affecting or pagination) before warning that the marker is orphaned.
- */ var DEFAULT_CONSTRAINT_FACTORY_NAMES = _to_consumable_array$1(DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES).concat(_to_consumable_array$1(DEFAULT_PAGINATION_CONSTRAINT_NAMES));
+ */ var DEFAULT_CONSTRAINT_FACTORY_NAMES = _to_consumable_array$2(DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES).concat(_to_consumable_array$2(DEFAULT_PAGINATION_CONSTRAINT_NAMES));
 /**
  * Creates an empty {@link ImportRegistry}.
  *
@@ -592,30 +592,30 @@ function _unsupported_iterable_to_array$2(o, minLen) {
     return result;
 }
 
-function _array_like_to_array$1(arr, len) {
+function _array_like_to_array$3(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+function _array_without_holes$1(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
 }
-function _iterable_to_array(iter) {
+function _iterable_to_array$1(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread() {
+function _non_iterable_spread$1() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread();
+function _to_consumable_array$1(arr) {
+    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$1();
 }
-function _unsupported_iterable_to_array$1(o, minLen) {
+function _unsupported_iterable_to_array$3(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$3(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$3(o, minLen);
 }
 /**
  * ESLint rule that forbids inline `@dereekb/firebase` Firestore constraint factory calls
@@ -673,7 +673,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
         var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
         var sourceCode = context.sourceCode;
         var baseNames = (_options_constraintNames = options.constraintNames) !== null && _options_constraintNames !== void 0 ? _options_constraintNames : DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES;
-        var constraintNames = new Set(_to_consumable_array(baseNames).concat(_to_consumable_array((_options_additionalConstraintNames = options.additionalConstraintNames) !== null && _options_additionalConstraintNames !== void 0 ? _options_additionalConstraintNames : [])));
+        var constraintNames = new Set(_to_consumable_array$1(baseNames).concat(_to_consumable_array$1((_options_additionalConstraintNames = options.additionalConstraintNames) !== null && _options_additionalConstraintNames !== void 0 ? _options_additionalConstraintNames : [])));
         var allowedSources = new Set((_options_allowedImportSources = options.allowedImportSources) !== null && _options_allowedImportSources !== void 0 ? _options_allowedImportSources : [
             FIREBASE_MODULE
         ]);
@@ -943,15 +943,15 @@ var DEFAULT_STRIPPABLE_SUFFIXES = [
     }
 };
 
-function _array_like_to_array(arr, len) {
+function _array_like_to_array$2(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_with_holes(arr) {
+function _array_with_holes$1(arr) {
     if (Array.isArray(arr)) return arr;
 }
-function _iterable_to_array_limit(arr, i) {
+function _iterable_to_array_limit$1(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
     var _arr = [];
@@ -975,19 +975,19 @@ function _iterable_to_array_limit(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest() {
+function _non_iterable_rest$1() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+function _sliced_to_array$1(arr, i) {
+    return _array_with_holes$1(arr) || _iterable_to_array_limit$1(arr, i) || _unsupported_iterable_to_array$2(arr, i) || _non_iterable_rest$1();
 }
-function _unsupported_iterable_to_array(o, minLen) {
+function _unsupported_iterable_to_array$2(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$2(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$2(o, minLen);
 }
 /**
  * Shared helpers for the `@dbx<Family>` companion-tag ESLint rules. Mirrors the
@@ -1270,7 +1270,7 @@ function emitUnknownCompanions(groups, knownSuffixes, emit) {
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         for(var _iterator = groups.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _step_value = _sliced_to_array(_step.value, 2), suffix = _step_value[0], instances = _step_value[1];
+            var _step_value = _sliced_to_array$1(_step.value, 2), suffix = _step_value[0], instances = _step_value[1];
             if (knownSuffixes.has(suffix)) continue;
             var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
             try {
@@ -2257,6 +2257,876 @@ function _type_of(obj) {
     }
 };
 
+function _array_like_to_array$1(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
+}
+/**
+ * ESLint rule that warns when an `@dereekb/firebase` field-path-narrowing constraint factory
+ * (`where`, `orderBy`) is called without a generic type argument. Without `<Model>`, the
+ * overload falls back to a plain `FieldPathOrStringPath`, so field-name typos and renamed
+ * fields silently compile.
+ *
+ * The expected form is `where<Model>('field', '==', value)` / `orderBy<Model>('field')` so
+ * the field path is constrained to `StringKeyPropertyKeys<Model>`.
+ *
+ * Not auto-fixable: the rule cannot safely infer the correct model type from the surrounding
+ * function signature in an ESLint autofix.
+ */ var FIREBASE_REQUIRE_FIRESTORE_CONSTRAINT_TYPE_PARAMETER_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: undefined,
+        docs: {
+            description: 'Require a generic type argument on `@dereekb/firebase` field-path-narrowing Firestore constraint factories (`where`, `orderBy`) so TypeScript verifies the field path against the model.',
+            recommended: true
+        },
+        messages: {
+            missingTypeParameter: '`{{name}}(...)` is missing a generic type parameter. Use `{{name}}<Model>(...)` so TypeScript can verify the field path against the model.'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    constraintNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    additionalConstraintNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    allowedImportSources: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_constraintNames, _options_additionalConstraintNames, _options_allowedImportSources;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var baseNames = (_options_constraintNames = options.constraintNames) !== null && _options_constraintNames !== void 0 ? _options_constraintNames : DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES;
+        var constraintNames = new Set(_to_consumable_array(baseNames).concat(_to_consumable_array((_options_additionalConstraintNames = options.additionalConstraintNames) !== null && _options_additionalConstraintNames !== void 0 ? _options_additionalConstraintNames : [])));
+        var allowedSources = new Set((_options_allowedImportSources = options.allowedImportSources) !== null && _options_allowedImportSources !== void 0 ? _options_allowedImportSources : [
+            FIREBASE_MODULE
+        ]);
+        var registry = createImportRegistry();
+        function isTrackedConstraintCall(node) {
+            var _node_callee;
+            var result = null;
+            if (((_node_callee = node.callee) === null || _node_callee === void 0 ? void 0 : _node_callee.type) === 'Identifier') {
+                var localName = node.callee.name;
+                var source = registry.localToSource.get(localName);
+                if (source && allowedSources.has(source) && isImportedFrom(registry, localName, source)) {
+                    var _registry_localToImported_get;
+                    var importedName = (_registry_localToImported_get = registry.localToImported.get(localName)) !== null && _registry_localToImported_get !== void 0 ? _registry_localToImported_get : localName;
+                    if (constraintNames.has(importedName)) {
+                        result = importedName;
+                    }
+                }
+            }
+            return result;
+        }
+        function hasTypeArgument(node) {
+            var _node_typeArguments;
+            var args = (_node_typeArguments = node.typeArguments) !== null && _node_typeArguments !== void 0 ? _node_typeArguments : node.typeParameters;
+            return Boolean(args && Array.isArray(args.params) && args.params.length > 0);
+        }
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                return trackImportDeclaration(registry, node);
+            },
+            CallExpression: function CallExpression(node) {
+                var name = isTrackedConstraintCall(node);
+                if (name && !hasTypeArgument(node)) {
+                    context.report({
+                        node: node.callee,
+                        messageId: 'missingTypeParameter',
+                        data: {
+                            name: name
+                        }
+                    });
+                }
+            }
+        };
+    }
+};
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Type-reference name that triggers this rule. Variables whose declared type is
+ * `ModelFirebaseCrudFunctionConfigMap<ConfigType, Identity>` will have their
+ * initializer validated against the structure of `ConfigType`.
+ */ var MODEL_FIREBASE_CRUD_FUNCTION_CONFIG_MAP_TYPE_NAME = 'ModelFirebaseCrudFunctionConfigMap';
+/**
+ * CRUD verb names supported by `ModelFirebaseCrudFunctionConfigMap`. Mirrors the
+ * `create | read | update | delete | query` verbs in the type definition at
+ * `packages/firebase/src/lib/client/function/model.function.factory.ts`.
+ */ var DEFAULT_CRUD_VERB_NAMES = [
+    'create',
+    'read',
+    'update',
+    'delete',
+    'query'
+];
+/**
+ * Unwraps `TSAsExpression` and `TSTypeAssertion` wrappers so the rule can see
+ * through type-system escape hatches like `'update:_,resync' as any` or
+ * `'update:_' as const`. These casts are common in real CRUD configs when the
+ * compiler's template-literal union for verb:specifier combinations exceeds
+ * the type checker's combinatorial budget — the whole point of this rule is
+ * to do the structural check that TypeScript gave up on.
+ *
+ * @param node - The AST node to unwrap.
+ * @returns The innermost wrapped expression, or `node` when no cast is present.
+ */ function unwrapTypeAssertion(node) {
+    var current = node;
+    while(current && (current.type === 'TSAsExpression' || current.type === 'TSTypeAssertion') && current.expression){
+        current = current.expression;
+    }
+    return current;
+}
+function propertyKeyName(key) {
+    var result = null;
+    if (key) {
+        if (key.type === 'Identifier') {
+            result = key.name;
+        } else if (key.type === 'Literal' && typeof key.value === 'string') {
+            result = key.value;
+        }
+    }
+    return result;
+}
+function typeReferenceTypeName(node) {
+    var _node_typeName;
+    var result = null;
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'TSTypeReference' && ((_node_typeName = node.typeName) === null || _node_typeName === void 0 ? void 0 : _node_typeName.type) === 'Identifier') {
+        result = node.typeName.name;
+    }
+    return result;
+}
+function typeArgumentNodes(node) {
+    var _node_typeArguments;
+    var args = (_node_typeArguments = node.typeArguments) !== null && _node_typeArguments !== void 0 ? _node_typeArguments : node.typeParameters;
+    return args && Array.isArray(args.params) ? args.params : [];
+}
+function findTypeAliasDeclaration(program, name) {
+    var result = null;
+    if (program && Array.isArray(program.body)) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = program.body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var statement = _step.value;
+                var _statement_declaration, _candidate_id;
+                if (result) break;
+                var candidate = null;
+                if ((statement === null || statement === void 0 ? void 0 : statement.type) === 'TSTypeAliasDeclaration') {
+                    candidate = statement;
+                } else if ((statement === null || statement === void 0 ? void 0 : statement.type) === 'ExportNamedDeclaration' && ((_statement_declaration = statement.declaration) === null || _statement_declaration === void 0 ? void 0 : _statement_declaration.type) === 'TSTypeAliasDeclaration') {
+                    candidate = statement.declaration;
+                }
+                if ((candidate === null || candidate === void 0 ? void 0 : (_candidate_id = candidate.id) === null || _candidate_id === void 0 ? void 0 : _candidate_id.type) === 'Identifier' && candidate.id.name === name) {
+                    result = candidate;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return result;
+}
+function extractVerbShape(verbKey, verbValueNode) {
+    var specifiers = null;
+    if ((verbValueNode === null || verbValueNode === void 0 ? void 0 : verbValueNode.type) === 'TSTypeLiteral' && Array.isArray(verbValueNode.members)) {
+        specifiers = new Set();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = verbValueNode.members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var inner = _step.value;
+                if ((inner === null || inner === void 0 ? void 0 : inner.type) === 'TSPropertySignature') {
+                    var specName = propertyKeyName(inner.key);
+                    if (specName) {
+                        specifiers.add(specName);
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return {
+        verb: verbKey,
+        specifiers: specifiers
+    };
+}
+function extractModelShape(input) {
+    var typeName = input.typeName, modelKey = input.modelKey, modelAnnotation = input.modelAnnotation, verbNames = input.verbNames, context = input.context;
+    var verbs = new Map();
+    if ((modelAnnotation === null || modelAnnotation === void 0 ? void 0 : modelAnnotation.type) === 'TSTypeLiteral' && Array.isArray(modelAnnotation.members)) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = modelAnnotation.members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var verbMember = _step.value;
+                var _verbMember_typeAnnotation;
+                if ((verbMember === null || verbMember === void 0 ? void 0 : verbMember.type) !== 'TSPropertySignature') continue;
+                var verbName = propertyKeyName(verbMember.key);
+                if (!verbName) continue;
+                if (!verbNames.has(verbName)) {
+                    context.report({
+                        node: verbMember,
+                        messageId: 'unsupportedVerbInType',
+                        data: {
+                            key: modelKey,
+                            verb: verbName,
+                            typeName: typeName
+                        }
+                    });
+                    continue;
+                }
+                var verbValue = (_verbMember_typeAnnotation = verbMember.typeAnnotation) === null || _verbMember_typeAnnotation === void 0 ? void 0 : _verbMember_typeAnnotation.typeAnnotation;
+                verbs.set(verbName, extractVerbShape(verbName, verbValue));
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return {
+        key: modelKey,
+        disabled: false,
+        verbs: verbs
+    };
+}
+function extractExpectedConfigShape(input) {
+    var typeName = input.typeName, typeAlias = input.typeAlias, verbNames = input.verbNames, context = input.context;
+    var result = null;
+    var typeAnnotation = typeAlias.typeAnnotation;
+    if ((typeAnnotation === null || typeAnnotation === void 0 ? void 0 : typeAnnotation.type) !== 'TSTypeLiteral' || !Array.isArray(typeAnnotation.members)) {
+        context.report({
+            node: typeAlias,
+            messageId: 'expectedTypeLiteral',
+            data: {
+                name: typeName
+            }
+        });
+    } else {
+        var models = new Map();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = typeAnnotation.members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var member = _step.value;
+                var _member_typeAnnotation;
+                if ((member === null || member === void 0 ? void 0 : member.type) !== 'TSPropertySignature') continue;
+                var modelKey = propertyKeyName(member.key);
+                if (!modelKey) continue;
+                var modelAnnotation = (_member_typeAnnotation = member.typeAnnotation) === null || _member_typeAnnotation === void 0 ? void 0 : _member_typeAnnotation.typeAnnotation;
+                if ((modelAnnotation === null || modelAnnotation === void 0 ? void 0 : modelAnnotation.type) === 'TSNullKeyword') {
+                    models.set(modelKey, {
+                        key: modelKey,
+                        disabled: true,
+                        verbs: new Map()
+                    });
+                } else if ((modelAnnotation === null || modelAnnotation === void 0 ? void 0 : modelAnnotation.type) === 'TSTypeLiteral') {
+                    models.set(modelKey, extractModelShape({
+                        typeName: typeName,
+                        modelKey: modelKey,
+                        modelAnnotation: modelAnnotation,
+                        verbNames: verbNames,
+                        context: context
+                    }));
+                } else {
+                    context.report({
+                        node: member,
+                        messageId: 'unsupportedConfigShape',
+                        data: {
+                            key: modelKey,
+                            typeName: typeName
+                        }
+                    });
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        result = {
+            typeName: typeName,
+            models: models
+        };
+    }
+    return result;
+}
+function parseEntryString(value) {
+    var colonIndex = value.indexOf(':');
+    var verb = colonIndex === -1 ? value : value.slice(0, colonIndex);
+    var hasSpecifiersPortion = colonIndex !== -1;
+    var specifiersCsv = hasSpecifiersPortion ? value.slice(colonIndex + 1) : '';
+    return {
+        entry: value,
+        verb: verb,
+        hasSpecifiersPortion: hasSpecifiersPortion,
+        specifiersCsv: specifiersCsv
+    };
+}
+function validateSpecifierList(input) {
+    var element = input.element, modelKey = input.modelKey, verb = input.verb, specifiersCsv = input.specifiersCsv, expectedSpecifiers = input.expectedSpecifiers, typeName = input.typeName, context = input.context;
+    var actualSpecifiers = new Set();
+    var rawSpecifiers = specifiersCsv.split(',').map(function(s) {
+        return s.trim();
+    });
+    var specifierError = false;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = rawSpecifiers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var specifier = _step.value;
+            if (specifier === '') {
+                context.report({
+                    node: element,
+                    messageId: 'emptySpecifierInEntry',
+                    data: {
+                        key: modelKey,
+                        verb: verb
+                    }
+                });
+                specifierError = true;
+                continue;
+            }
+            if (actualSpecifiers.has(specifier)) {
+                context.report({
+                    node: element,
+                    messageId: 'duplicateSpecifierInEntry',
+                    data: {
+                        key: modelKey,
+                        verb: verb,
+                        specifier: specifier
+                    }
+                });
+                specifierError = true;
+                continue;
+            }
+            actualSpecifiers.add(specifier);
+            if (!expectedSpecifiers.has(specifier)) {
+                context.report({
+                    node: element,
+                    messageId: 'unknownSpecifier',
+                    data: {
+                        key: modelKey,
+                        verb: verb,
+                        specifier: specifier,
+                        typeName: typeName
+                    }
+                });
+                specifierError = true;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (!specifierError) {
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = expectedSpecifiers[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var expected = _step1.value;
+                if (!actualSpecifiers.has(expected)) {
+                    context.report({
+                        node: element,
+                        messageId: 'missingSpecifier',
+                        data: {
+                            key: modelKey,
+                            verb: verb,
+                            specifier: expected
+                        }
+                    });
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+    }
+}
+function validateEntry(input) {
+    var element = input.element, modelKey = input.modelKey, expectedModel = input.expectedModel, typeName = input.typeName, seenVerbs = input.seenVerbs, context = input.context;
+    var unwrapped = unwrapTypeAssertion(element);
+    if (unwrapped.type !== 'Literal' || typeof unwrapped.value !== 'string') {
+        context.report({
+            node: element,
+            messageId: 'expectedStringArray',
+            data: {
+                key: modelKey
+            }
+        });
+        return;
+    }
+    var parsed = parseEntryString(unwrapped.value);
+    var expectedVerb = expectedModel.verbs.get(parsed.verb);
+    if (!expectedVerb) {
+        context.report({
+            node: element,
+            messageId: 'unknownVerbInEntry',
+            data: {
+                key: modelKey,
+                verb: parsed.verb,
+                entry: parsed.entry,
+                typeName: typeName
+            }
+        });
+        return;
+    }
+    if (seenVerbs.has(parsed.verb)) {
+        context.report({
+            node: element,
+            messageId: 'duplicateVerbInEntry',
+            data: {
+                key: modelKey,
+                verb: parsed.verb
+            }
+        });
+        return;
+    }
+    seenVerbs.add(parsed.verb);
+    if (expectedVerb.specifiers == null) {
+        if (parsed.hasSpecifiersPortion) {
+            context.report({
+                node: element,
+                messageId: 'unexpectedSpecifiersForVerb',
+                data: {
+                    key: modelKey,
+                    verb: parsed.verb,
+                    entry: parsed.entry
+                }
+            });
+        }
+        return;
+    }
+    if (!parsed.hasSpecifiersPortion) {
+        context.report({
+            node: element,
+            messageId: 'missingSpecifiersForVerb',
+            data: {
+                key: modelKey,
+                verb: parsed.verb,
+                entry: parsed.entry
+            }
+        });
+        return;
+    }
+    validateSpecifierList({
+        element: element,
+        modelKey: modelKey,
+        verb: parsed.verb,
+        specifiersCsv: parsed.specifiersCsv,
+        expectedSpecifiers: expectedVerb.specifiers,
+        typeName: typeName,
+        context: context
+    });
+}
+function validateModelEntry(input) {
+    var modelKey = input.modelKey, expectedModel = input.expectedModel, valueNode = input.valueNode, typeName = input.typeName, context = input.context;
+    var unwrapped = unwrapTypeAssertion(valueNode);
+    if ((unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped.type) !== 'ArrayExpression' || !Array.isArray(unwrapped.elements)) {
+        context.report({
+            node: valueNode,
+            messageId: 'expectedStringArray',
+            data: {
+                key: modelKey
+            }
+        });
+        return;
+    }
+    var seenVerbs = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = unwrapped.elements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var element = _step.value;
+            if (element == null) continue;
+            validateEntry({
+                element: element,
+                modelKey: modelKey,
+                expectedModel: expectedModel,
+                typeName: typeName,
+                seenVerbs: seenVerbs,
+                context: context
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        for(var _iterator1 = expectedModel.verbs.keys()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var expectedVerbName = _step1.value;
+            if (!seenVerbs.has(expectedVerbName)) {
+                context.report({
+                    node: valueNode,
+                    messageId: 'missingVerb',
+                    data: {
+                        key: modelKey,
+                        verb: expectedVerbName,
+                        typeName: typeName
+                    }
+                });
+            }
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+}
+/**
+ * ESLint rule that verifies every `ModelFirebaseCrudFunctionConfigMap<ConfigType, ...>`
+ * variable initializer is structurally complete against its companion `ConfigType`
+ * defined in the same file.
+ *
+ * The rule walks the type alias for `ConfigType` (e.g., `NotificationBoxModelCrudFunctionsConfig`),
+ * builds the expected set of model keys, verbs, and specifiers, and then compares it
+ * against the object-literal initializer of the variable. Each mismatch — missing model
+ * key, missing verb, missing specifier, disabled-but-present key, etc. — is reported as
+ * an error so the const stays in sync with its companion type even when the TypeScript
+ * mapped-type enforcement decays in larger codebases.
+ *
+ * Same-file resolution only: the companion type must be declared in the same source
+ * file as the const (matching the convention in `notification.api.ts`, `oidcmodel.api.ts`,
+ * `storagefile.api.ts`). When the type cannot be located, the rule reports
+ * `configTypeNotFound`.
+ */ var FIREBASE_REQUIRE_COMPLETE_CRUD_FUNCTION_CONFIG_MAP_RULE = {
+    meta: {
+        type: 'problem',
+        fixable: undefined,
+        docs: {
+            description: 'Require that a `ModelFirebaseCrudFunctionConfigMap<ConfigType, Identity>` initializer matches the model keys, verbs, and specifiers declared by its companion `ConfigType` defined in the same file.',
+            recommended: true
+        },
+        messages: {
+            configTypeNotFound: 'Companion type "{{name}}" not found in the same file. Define the *CrudFunctionsConfig type alongside the const so the rule can verify it.',
+            expectedTypeLiteral: 'Companion type "{{name}}" must be an inline type literal (object type) so the rule can verify it.',
+            expectedObjectLiteral: 'CRUD config map initializer must be an inline object literal so the rule can verify it.',
+            expectedStringArray: 'CRUD entry for "{{key}}" must be an array of string literals.',
+            missingModelKey: 'CRUD config is missing model key "{{key}}". The type "{{typeName}}" declares it as enabled (not null).',
+            disabledModelKeyPresent: 'Model key "{{key}}" is disabled (null) in "{{typeName}}" and must not appear in the CRUD config.',
+            unknownModelKey: 'Model key "{{key}}" is not declared in "{{typeName}}".',
+            missingVerb: 'CRUD entry for "{{key}}" is missing verb "{{verb}}" declared in "{{typeName}}".',
+            unknownVerbInEntry: 'CRUD entry "{{entry}}" for "{{key}}" uses verb "{{verb}}" which is not declared in "{{typeName}}".',
+            duplicateVerbInEntry: 'CRUD entry for "{{key}}" declares verb "{{verb}}" more than once.',
+            missingSpecifier: 'CRUD entry for "{{key}}.{{verb}}" is missing specifier "{{specifier}}".',
+            unknownSpecifier: 'CRUD entry for "{{key}}.{{verb}}" declares specifier "{{specifier}}" which is not in "{{typeName}}".',
+            duplicateSpecifierInEntry: 'CRUD entry for "{{key}}.{{verb}}" declares specifier "{{specifier}}" more than once.',
+            emptySpecifierInEntry: 'CRUD entry for "{{key}}.{{verb}}" contains an empty specifier (check for stray commas).',
+            missingSpecifiersForVerb: 'CRUD entry "{{entry}}" for "{{key}}.{{verb}}" is missing its specifier list (expected `{{verb}}:<specifier>,...`).',
+            unexpectedSpecifiersForVerb: 'CRUD entry "{{entry}}" for "{{key}}.{{verb}}" includes specifiers but the type declares the verb without any.',
+            unsupportedConfigShape: 'Property "{{key}}" in "{{typeName}}" has an unsupported shape. Expected null or an object type with verbs.',
+            unsupportedVerbInType: 'Verb "{{verb}}" on "{{key}}" in "{{typeName}}" is not a recognized CRUD verb. Expected one of: create, read, update, delete, query.'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    typeName: {
+                        type: 'string'
+                    },
+                    verbNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_typeName, _options_verbNames;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var triggerTypeName = (_options_typeName = options.typeName) !== null && _options_typeName !== void 0 ? _options_typeName : MODEL_FIREBASE_CRUD_FUNCTION_CONFIG_MAP_TYPE_NAME;
+        var verbNames = new Set((_options_verbNames = options.verbNames) !== null && _options_verbNames !== void 0 ? _options_verbNames : DEFAULT_CRUD_VERB_NAMES);
+        var programNode = null;
+        return {
+            Program: function Program(node) {
+                programNode = node;
+            },
+            VariableDeclarator: function VariableDeclarator(node) {
+                var _node_id_typeAnnotation, _node_id;
+                var typeAnnotation = (_node_id = node.id) === null || _node_id === void 0 ? void 0 : (_node_id_typeAnnotation = _node_id.typeAnnotation) === null || _node_id_typeAnnotation === void 0 ? void 0 : _node_id_typeAnnotation.typeAnnotation;
+                if (typeReferenceTypeName(typeAnnotation) !== triggerTypeName) return;
+                var typeArgs = typeArgumentNodes(typeAnnotation);
+                var configTypeArg = typeArgs[0];
+                var configTypeName = typeReferenceTypeName(configTypeArg);
+                if (!configTypeName) return;
+                if (!programNode) return;
+                var typeAlias = findTypeAliasDeclaration(programNode, configTypeName);
+                if (!typeAlias) {
+                    context.report({
+                        node: configTypeArg,
+                        messageId: 'configTypeNotFound',
+                        data: {
+                            name: configTypeName
+                        }
+                    });
+                    return;
+                }
+                var expected = extractExpectedConfigShape({
+                    typeName: configTypeName,
+                    typeAlias: typeAlias,
+                    verbNames: verbNames,
+                    context: context
+                });
+                if (!expected) return;
+                var initializer = node.init ? unwrapTypeAssertion(node.init) : null;
+                if ((initializer === null || initializer === void 0 ? void 0 : initializer.type) !== 'ObjectExpression' || !Array.isArray(initializer.properties)) {
+                    var _node_init;
+                    context.report({
+                        node: (_node_init = node.init) !== null && _node_init !== void 0 ? _node_init : node,
+                        messageId: 'expectedObjectLiteral'
+                    });
+                    return;
+                }
+                var seenKeys = new Set();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = initializer.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var property = _step.value;
+                        if ((property === null || property === void 0 ? void 0 : property.type) !== 'Property') continue;
+                        var modelKey = propertyKeyName(property.key);
+                        if (!modelKey) continue;
+                        seenKeys.add(modelKey);
+                        var expectedModel = expected.models.get(modelKey);
+                        if (!expectedModel) {
+                            context.report({
+                                node: property.key,
+                                messageId: 'unknownModelKey',
+                                data: {
+                                    key: modelKey,
+                                    typeName: configTypeName
+                                }
+                            });
+                            continue;
+                        }
+                        if (expectedModel.disabled) {
+                            context.report({
+                                node: property.key,
+                                messageId: 'disabledModelKeyPresent',
+                                data: {
+                                    key: modelKey,
+                                    typeName: configTypeName
+                                }
+                            });
+                            continue;
+                        }
+                        validateModelEntry({
+                            modelKey: modelKey,
+                            expectedModel: expectedModel,
+                            valueNode: property.value,
+                            typeName: configTypeName,
+                            context: context
+                        });
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = expected.models[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var _step_value = _sliced_to_array(_step1.value, 2), expectedKey = _step_value[0], expectedModel1 = _step_value[1];
+                        if (!expectedModel1.disabled && !seenKeys.has(expectedKey)) {
+                            context.report({
+                                node: initializer,
+                                messageId: 'missingModelKey',
+                                data: {
+                                    key: expectedKey,
+                                    typeName: configTypeName
+                                }
+                            });
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+
 /**
  * ESLint plugin for `@dereekb/firebase` rules.
  *
@@ -2267,7 +3137,9 @@ function _type_of(obj) {
         'require-tagged-firestore-constraints': FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE,
         'require-dbx-model-firebase-index-query-suffix': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE,
         'require-dbx-model-firebase-index-companion-tags': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE,
-        'require-dbx-model-firebase-index-valid-dispatcher': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE
+        'require-dbx-model-firebase-index-valid-dispatcher': FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE,
+        'require-firestore-constraint-type-parameter': FIREBASE_REQUIRE_FIRESTORE_CONSTRAINT_TYPE_PARAMETER_RULE,
+        'require-complete-crud-function-config-map': FIREBASE_REQUIRE_COMPLETE_CRUD_FUNCTION_CONFIG_MAP_RULE
     }
 };
 /**
@@ -2278,13 +3150,17 @@ function _type_of(obj) {
 
 exports.DBX_MODEL_FIREBASE_INDEX_MARKER = DBX_MODEL_FIREBASE_INDEX_MARKER;
 exports.DEFAULT_CONSTRAINT_FACTORY_NAMES = DEFAULT_CONSTRAINT_FACTORY_NAMES;
+exports.DEFAULT_CRUD_VERB_NAMES = DEFAULT_CRUD_VERB_NAMES;
 exports.DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES = DEFAULT_INDEX_AFFECTING_CONSTRAINT_NAMES;
 exports.DEFAULT_PAGINATION_CONSTRAINT_NAMES = DEFAULT_PAGINATION_CONSTRAINT_NAMES;
 exports.FIREBASE_ESLINT_PLUGIN = FIREBASE_ESLINT_PLUGIN;
 exports.FIREBASE_MODULE = FIREBASE_MODULE;
+exports.FIREBASE_REQUIRE_COMPLETE_CRUD_FUNCTION_CONFIG_MAP_RULE = FIREBASE_REQUIRE_COMPLETE_CRUD_FUNCTION_CONFIG_MAP_RULE;
 exports.FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE = FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_COMPANION_TAGS_RULE;
 exports.FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE = FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_QUERY_SUFFIX_RULE;
 exports.FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE = FIREBASE_REQUIRE_DBX_MODEL_FIREBASE_INDEX_VALID_DISPATCHER_RULE;
+exports.FIREBASE_REQUIRE_FIRESTORE_CONSTRAINT_TYPE_PARAMETER_RULE = FIREBASE_REQUIRE_FIRESTORE_CONSTRAINT_TYPE_PARAMETER_RULE;
 exports.FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE = FIREBASE_REQUIRE_TAGGED_FIRESTORE_CONSTRAINTS_RULE;
+exports.MODEL_FIREBASE_CRUD_FUNCTION_CONFIG_MAP_TYPE_NAME = MODEL_FIREBASE_CRUD_FUNCTION_CONFIG_MAP_TYPE_NAME;
 exports.QUERY_SUFFIX = QUERY_SUFFIX;
 exports.firebaseESLintPlugin = firebaseESLintPlugin;