@dereekb/firebase 13.35.0 → 13.37.0

package/eslint/index.cjs.js

@@ -18078,6 +18078,500 @@ function _unsupported_iterable_to_array(o, minLen) {
     }
 };
 
+/**
+ * Name of the `@dereekb/model` helper that expands an arktype definition to `T | null | undefined`.
+ */ var CLEARABLE_FUNCTION_NAME = 'clearable';
+/**
+ * Module that publishes {@link CLEARABLE_FUNCTION_NAME}.
+ */ var CLEARABLE_IMPORT_MODULE = '@dereekb/model';
+/**
+ * Identifier callees whose object-literal argument is an arktype definition (`type({ ... })`, `scope({ ... })`).
+ */ var DEFAULT_ARKTYPE_DEFINITION_CALLEE_NAMES = [
+    'type',
+    'scope'
+];
+/**
+ * Arktype combinator methods that take an object-literal definition (`targetModelParamsType.merge({ ... })`).
+ */ var DEFAULT_ARKTYPE_COMBINATOR_METHOD_NAMES = [
+    'merge',
+    'and',
+    'or',
+    'extend'
+];
+/**
+ * Method used to union an existing Type with another definition (`someType.or('null | undefined')`).
+ */ var OR_METHOD_NAME = 'or';
+/**
+ * The nullish arktype keywords {@link CLEARABLE_FUNCTION_NAME} appends to its definition.
+ */ var NULLISH_KEYWORDS = new Set([
+    'null',
+    'undefined'
+]);
+/**
+ * Splits an arktype definition into its top-level `|` members, ignoring separators nested inside
+ * quotes, parentheses, brackets, or braces (`${...}` template holes included).
+ *
+ * @param text - The definition text, without its surrounding quote/backtick delimiters.
+ * @returns The union members in source order.
+ */ function splitTopLevelUnion(text) {
+    var members = [];
+    var depth = 0;
+    var quote = null;
+    var start = 0;
+    for(var i = 0; i < text.length; i += 1){
+        var char = text[i];
+        if (quote != null) {
+            if (char === '\\') {
+                i += 1;
+            } else if (char === quote) {
+                quote = null;
+            }
+        } else if (char === "'" || char === '"') {
+            quote = char;
+        } else if (char === '(' || char === '[' || char === '{') {
+            depth += 1;
+        } else if (char === ')' || char === ']' || char === '}') {
+            depth -= 1;
+        } else if (char === '|' && depth === 0) {
+            members.push({
+                text: text.slice(start, i),
+                start: start
+            });
+            start = i + 1;
+        }
+    }
+    members.push({
+        text: text.slice(start),
+        start: start
+    });
+    return members;
+}
+/**
+ * Inspects an arktype definition for top-level `null` / `undefined` union members.
+ *
+ * @param text - The definition text, without its surrounding quote/backtick delimiters.
+ * @returns The nullish members found and the definition text with a trailing nullish run removed.
+ */ function splitNullishUnion(text) {
+    var members = splitTopLevelUnion(text);
+    var hasNull = false;
+    var hasUndefined = false;
+    var nullishIsSuffix = true;
+    var firstNullishStart = null;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var member = _step.value;
+            var trimmed = member.text.trim();
+            if (NULLISH_KEYWORDS.has(trimmed)) {
+                hasNull = hasNull || trimmed === 'null';
+                hasUndefined = hasUndefined || trimmed === 'undefined';
+                if (firstNullishStart == null) {
+                    firstNullishStart = member.start;
+                }
+            } else if (firstNullishStart != null) {
+                nullishIsSuffix = false;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var base = firstNullishStart == null ? text : text.slice(0, firstNullishStart).replace(/[\s|]+$/, '');
+    return {
+        base: base,
+        hasNull: hasNull,
+        hasUndefined: hasUndefined,
+        nullishIsSuffix: nullishIsSuffix
+    };
+}
+/**
+ * Returns true when the node is a string literal or a template literal — the two forms an arktype
+ * definition string is written in.
+ *
+ * @param node - The property value node.
+ * @returns True when the node is a definition string.
+ */ function isDefinitionStringNode(node) {
+    return (node === null || node === void 0 ? void 0 : node.type) === 'Literal' && typeof node.value === 'string' || (node === null || node === void 0 ? void 0 : node.type) === 'TemplateLiteral';
+}
+/**
+ * Returns true when the callee is one an arktype object-literal definition is passed to.
+ *
+ * @param callee - The `CallExpression` callee node.
+ * @param definitionCalleeNames - Identifier callee names (e.g. `type`).
+ * @param combinatorMethodNames - Member-expression method names (e.g. `merge`).
+ * @returns True when the call takes an arktype definition.
+ */ function isArktypeDefinitionCallee(callee, definitionCalleeNames, combinatorMethodNames) {
+    var _callee_property;
+    var result = false;
+    if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier') {
+        result = definitionCalleeNames.includes(callee.name);
+    } else if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'MemberExpression' && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier') {
+        var _callee_object;
+        // `someType.merge({ … })` / `type.enumerated({ … })`
+        result = combinatorMethodNames.includes(callee.property.name) || ((_callee_object = callee.object) === null || _callee_object === void 0 ? void 0 : _callee_object.type) === 'Identifier' && definitionCalleeNames.includes(callee.object.name);
+    }
+    return result;
+}
+/**
+ * Walks out of a property to the outermost object literal it belongs to and returns the arktype call
+ * that literal is an argument of, or null when the property is not part of an arktype definition.
+ *
+ * Gating on the enclosing call keeps the rule off ordinary object literals that happen to hold a
+ * `'… | null | undefined'` string, and off `clearable`'s own implementation.
+ *
+ * @param property - The `Property` node being checked.
+ * @param definitionCalleeNames - Identifier callee names (e.g. `type`).
+ * @param combinatorMethodNames - Member-expression method names (e.g. `merge`).
+ * @returns The enclosing arktype `CallExpression`, or null.
+ */ function arktypeDefinitionCallForProperty(property, definitionCalleeNames, combinatorMethodNames) {
+    var current = property === null || property === void 0 ? void 0 : property.parent;
+    var result = null;
+    while(current != null){
+        var parent = current.parent;
+        if (current.type !== 'ObjectExpression') {
+            current = null;
+        } else if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Property') {
+            current = parent.parent; // nested definition — climb to the enclosing object literal
+        } else {
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'CallExpression' && isArktypeDefinitionCallee(parent.callee, definitionCalleeNames, combinatorMethodNames)) {
+                result = parent;
+            }
+            current = null;
+        }
+    }
+    return result;
+}
+/**
+ * Unwraps a `X.or('null').or('undefined')` / `X.or('null | undefined')` chain.
+ *
+ * @param node - The property value node.
+ * @param sourceCode - The ESLint `SourceCode` object.
+ * @returns The chain's receiver plus the nullish members it appends, or null when the node is not a nullish `.or(...)` chain.
+ */ function unwrapNullishOrChain(node, sourceCode) {
+    var current = node;
+    var receiver = null;
+    var hasNull = false;
+    var hasUndefined = false;
+    while(current != null){
+        var _current_arguments, _callee_property;
+        var callee = current.type === 'CallExpression' ? current.callee : null;
+        var argument = current.type === 'CallExpression' && ((_current_arguments = current.arguments) === null || _current_arguments === void 0 ? void 0 : _current_arguments.length) === 1 ? current.arguments[0] : null;
+        var isOrCall = (callee === null || callee === void 0 ? void 0 : callee.type) === 'MemberExpression' && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier' && callee.property.name === OR_METHOD_NAME;
+        // only a wholly-nullish argument (`'null'`, `'undefined'`, `'null | undefined'`) is part of the chain
+        var split = isOrCall && argument != null && isDefinitionStringNode(argument) ? splitNullishUnion(sourceCode.getText(argument).slice(1, -1)) : null;
+        if ((split === null || split === void 0 ? void 0 : split.base.trim()) === '') {
+            hasNull = hasNull || split.hasNull;
+            hasUndefined = hasUndefined || split.hasUndefined;
+            receiver = callee.object;
+            current = receiver;
+        } else {
+            current = null;
+        }
+    }
+    return receiver == null ? null : {
+        receiver: receiver,
+        hasNull: hasNull,
+        hasUndefined: hasUndefined
+    };
+}
+/**
+ * Returns true when `name` is already bound at the top level of the program — imported, or declared
+ * in the file itself (as it is inside `@dereekb/model`).
+ *
+ * @param programNode - The `Program` node.
+ * @param name - The binding to look for.
+ * @returns True when the name is already available.
+ */ function hasTopLevelBinding(programNode, name) {
+    var _ref;
+    var body = (_ref = programNode === null || programNode === void 0 ? void 0 : programNode.body) !== null && _ref !== void 0 ? _ref : [];
+    var result = false;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var statement = _step.value;
+            var declaration = (statement === null || statement === void 0 ? void 0 : statement.type) === 'ExportNamedDeclaration' ? statement.declaration : statement;
+            if ((statement === null || statement === void 0 ? void 0 : statement.type) === 'ImportDeclaration') {
+                var _statement_specifiers;
+                result = result || ((_statement_specifiers = statement.specifiers) !== null && _statement_specifiers !== void 0 ? _statement_specifiers : []).some(function(specifier) {
+                    var _specifier_local;
+                    return (specifier === null || specifier === void 0 ? void 0 : (_specifier_local = specifier.local) === null || _specifier_local === void 0 ? void 0 : _specifier_local.name) === name;
+                });
+            } else if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'VariableDeclaration') {
+                var _declaration_declarations;
+                result = result || ((_declaration_declarations = declaration.declarations) !== null && _declaration_declarations !== void 0 ? _declaration_declarations : []).some(function(declarator) {
+                    var _declarator_id;
+                    return (declarator === null || declarator === void 0 ? void 0 : (_declarator_id = declarator.id) === null || _declarator_id === void 0 ? void 0 : _declarator_id.name) === name;
+                });
+            } else if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'FunctionDeclaration') {
+                var _declaration_id;
+                result = result || ((_declaration_id = declaration.id) === null || _declaration_id === void 0 ? void 0 : _declaration_id.name) === name;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * ESLint rule that requires arktype model/params definitions to express a clearable field with
+ * `clearable('TYPE')` rather than by unioning the nullish keywords inline
+ * (`'TYPE | null | undefined'`) or by appending them with `.or(...)`.
+ *
+ * `clearable(...)` is the workspace's canonical spelling for the `Maybe<T>` fields on a params
+ * interface: it names the semantic (`null` clears the field, `undefined` leaves it unchanged)
+ * instead of restating the union at every property, and it is what the model-api validator's
+ * `MAYBE_WITHOUT_CLEARABLE` check and the JSON Schema export helper both key off. An inline union
+ * decodes the same way today but drifts from both.
+ *
+ * Only properties of an object literal passed to an arktype definition call (`type({ … })`,
+ * `someType.merge({ … })`, …) are considered, so ordinary object literals — and `clearable`'s own
+ * implementation — are left alone.
+ *
+ * The fix rewrites the property value and, when the helper is not already in scope, adds its import
+ * (once per pass; the remaining properties are rewritten in the same pass alongside it). When no
+ * import can be anchored the violation is reported without a fix rather than emitting a reference to
+ * an unimported helper.
+ *
+ * @example
+ * ```ts
+ * // WARN — preferClearableDefinition
+ * export const updateWidgetParamsType = type({
+ *   'name?': 'string | null | undefined',
+ *   'tags?': 'string[] | null | undefined'
+ * });
+ *
+ * // WARN — preferClearableOrChain
+ * export const publishWidgetParamsType = type({
+ *   'entries?': widgetEntryParamsType.array().or('null | undefined')
+ * });
+ *
+ * // OK
+ * export const updateWidgetParamsType = type({
+ *   'name?': clearable('string'),
+ *   'tags?': clearable('string[]')
+ * });
+ * ```
+ */ var FIREBASE_PREFER_CLEARABLE_ARKTYPE_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Require `clearable(...)` from `@dereekb/model` for arktype definitions that union `null` / `undefined`, rather than spelling the nullish union inline.',
+            recommended: true
+        },
+        messages: {
+            preferClearableDefinition: 'Arktype definition `{{definition}}` unions the nullish keywords inline. Use `{{suggestion}}` instead — `{{helper}}(...)` from `{{module}}` is the canonical spelling for a clearable (`Maybe`) field.',
+            preferClearableOrChain: 'Arktype definition `{{definition}}` appends the nullish keywords with `.or(...)`. Use `{{suggestion}}` instead — `{{helper}}(...)` from `{{module}}` is the canonical spelling for a clearable (`Maybe`) field.'
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    clearableFunctionName: {
+                        type: 'string'
+                    },
+                    importModule: {
+                        type: 'string'
+                    },
+                    autoImport: {
+                        type: 'boolean'
+                    },
+                    includeSingleNullish: {
+                        type: 'boolean'
+                    },
+                    definitionCalleeNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    combinatorMethodNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        ]
+    },
+    create: function create(context) {
+        var _context_options_, _options_clearableFunctionName, _options_importModule, _options_definitionCalleeNames, _options_combinatorMethodNames;
+        var options = (_context_options_ = context.options[0]) !== null && _context_options_ !== void 0 ? _context_options_ : {};
+        var clearableName = (_options_clearableFunctionName = options.clearableFunctionName) !== null && _options_clearableFunctionName !== void 0 ? _options_clearableFunctionName : CLEARABLE_FUNCTION_NAME;
+        var importModule = (_options_importModule = options.importModule) !== null && _options_importModule !== void 0 ? _options_importModule : CLEARABLE_IMPORT_MODULE;
+        var autoImport = options.autoImport !== false;
+        var includeSingleNullish = options.includeSingleNullish === true;
+        var definitionCalleeNames = (_options_definitionCalleeNames = options.definitionCalleeNames) !== null && _options_definitionCalleeNames !== void 0 ? _options_definitionCalleeNames : DEFAULT_ARKTYPE_DEFINITION_CALLEE_NAMES;
+        var combinatorMethodNames = (_options_combinatorMethodNames = options.combinatorMethodNames) !== null && _options_combinatorMethodNames !== void 0 ? _options_combinatorMethodNames : DEFAULT_ARKTYPE_COMBINATOR_METHOD_NAMES;
+        var sourceCode = context.sourceCode;
+        var programNode = null;
+        var helperInScope = false;
+        var importAnchored = false;
+        var importFixUsed = false;
+        /**
+         * Returns the import declaration the helper's import is added to — an existing value import from
+         * `importModule` when there is one, otherwise the file's last import (appended after).
+         *
+         * @returns The anchor import and whether the helper merges into its specifier list, or null when the file has no import to anchor to.
+         */ function importAnchorFor() {
+            var _ref;
+            var imports = ((_ref = programNode === null || programNode === void 0 ? void 0 : programNode.body) !== null && _ref !== void 0 ? _ref : []).filter(function(statement) {
+                return (statement === null || statement === void 0 ? void 0 : statement.type) === 'ImportDeclaration';
+            });
+            var mergeable = imports.find(function(statement) {
+                var _statement_specifiers;
+                var _statement_source;
+                return ((_statement_source = statement.source) === null || _statement_source === void 0 ? void 0 : _statement_source.value) === importModule && statement.importKind !== 'type' && ((_statement_specifiers = statement.specifiers) !== null && _statement_specifiers !== void 0 ? _statement_specifiers : []).some(function(specifier) {
+                    return (specifier === null || specifier === void 0 ? void 0 : specifier.type) === 'ImportSpecifier';
+                });
+            });
+            var result = null;
+            if (mergeable != null) {
+                result = {
+                    node: mergeable,
+                    merge: true
+                };
+            } else if (imports.length > 0) {
+                result = {
+                    node: imports[imports.length - 1],
+                    merge: false
+                };
+            }
+            return result;
+        }
+        /**
+         * Builds the fix that brings the helper into scope, merging into an existing `importModule`
+         * import when there is one.
+         *
+         * @param fixer - The ESLint fixer.
+         * @returns The import fix, or null when no import can be anchored.
+         */ function buildImportFix(fixer) {
+            var anchor = importAnchorFor();
+            var result = null;
+            if ((anchor === null || anchor === void 0 ? void 0 : anchor.merge) === true) {
+                var firstNamed = anchor.node.specifiers.find(function(specifier) {
+                    return (specifier === null || specifier === void 0 ? void 0 : specifier.type) === 'ImportSpecifier';
+                });
+                result = fixer.insertTextBefore(firstNamed, "".concat(clearableName, ", "));
+            } else if (anchor != null) {
+                result = fixer.insertTextAfter(anchor.node, "\nimport { ".concat(clearableName, " } from '").concat(importModule, "';"));
+            }
+            return result;
+        }
+        /**
+         * Reports a definition, attaching the rewrite fix — plus the helper's import on the first report
+         * of the pass — only when the result would compile.
+         *
+         * @param valueNode - The definition node to replace.
+         * @param messageId - The message to report.
+         * @param suggestion - The `clearable(...)` replacement text.
+         */ function reportPreferClearable(valueNode, messageId, suggestion) {
+            var data = {
+                definition: sourceCode.getText(valueNode),
+                suggestion: suggestion,
+                helper: clearableName,
+                module: importModule
+            };
+            if (helperInScope || importAnchored) {
+                context.report({
+                    node: valueNode,
+                    messageId: messageId,
+                    data: data,
+                    fix: function fix(fixer) {
+                        var fixes = [
+                            fixer.replaceText(valueNode, suggestion)
+                        ];
+                        if (!helperInScope && !importFixUsed) {
+                            var importFix = buildImportFix(fixer);
+                            if (importFix != null) {
+                                importFixUsed = true;
+                                fixes.push(importFix);
+                            }
+                        }
+                        return fixes;
+                    }
+                });
+            } else {
+                // no import can be anchored — reporting a fix here would reference an unimported helper
+                context.report({
+                    node: valueNode,
+                    messageId: messageId,
+                    data: data
+                });
+            }
+        }
+        /**
+         * Checks a string/template definition for an inline nullish union.
+         *
+         * @param valueNode - The definition node.
+         */ function checkDefinitionString(valueNode) {
+            var text = sourceCode.getText(valueNode);
+            var delimiter = text.charAt(0);
+            var split = splitNullishUnion(text.slice(1, -1));
+            var bothNullish = split.hasNull && split.hasUndefined;
+            var anyNullish = split.hasNull || split.hasUndefined;
+            if ((bothNullish || includeSingleNullish && anyNullish) && split.nullishIsSuffix && split.base.trim() !== '') {
+                reportPreferClearable(valueNode, 'preferClearableDefinition', "".concat(clearableName, "(").concat(delimiter).concat(split.base).concat(delimiter, ")"));
+            }
+        }
+        /**
+         * Checks a call expression for a nullish `.or(...)` chain.
+         *
+         * @param valueNode - The definition node.
+         */ function checkOrChain(valueNode) {
+            var chain = unwrapNullishOrChain(valueNode, sourceCode);
+            if (chain != null) {
+                var bothNullish = chain.hasNull && chain.hasUndefined;
+                var anyNullish = chain.hasNull || chain.hasUndefined;
+                if (bothNullish || includeSingleNullish && anyNullish) {
+                    reportPreferClearable(valueNode, 'preferClearableOrChain', "".concat(clearableName, "(").concat(sourceCode.getText(chain.receiver), ")"));
+                }
+            }
+        }
+        return {
+            Program: function Program(node) {
+                programNode = node;
+                helperInScope = hasTopLevelBinding(node, clearableName);
+                importFixUsed = false;
+                importAnchored = autoImport && importAnchorFor() != null;
+            },
+            Property: function Property(node) {
+                var valueNode = node === null || node === void 0 ? void 0 : node.value;
+                if (valueNode != null && arktypeDefinitionCallForProperty(node, definitionCalleeNames, combinatorMethodNames) != null) {
+                    if (isDefinitionStringNode(valueNode)) {
+                        checkDefinitionString(valueNode);
+                    } else if (valueNode.type === 'CallExpression') {
+                        checkOrChain(valueNode);
+                    }
+                }
+            }
+        };
+    }
+};
+
 /**
  * ESLint plugin for `@dereekb/firebase` rules.
  *
@@ -18101,7 +18595,8 @@ function _unsupported_iterable_to_array(o, minLen) {
         'require-canonical-api-spec-filename': FIREBASE_REQUIRE_CANONICAL_API_SPEC_FILENAME_RULE,
         'require-api-crud-spec-for-group': FIREBASE_REQUIRE_API_CRUD_SPEC_FOR_GROUP_RULE,
         'require-dbx-model-api-params-tag': FIREBASE_REQUIRE_DBX_MODEL_API_PARAMS_TAG_RULE,
-        'require-use-model-roles': FIREBASE_REQUIRE_USE_MODEL_ROLES_RULE
+        'require-use-model-roles': FIREBASE_REQUIRE_USE_MODEL_ROLES_RULE,
+        'prefer-clearable-arktype': FIREBASE_PREFER_CLEARABLE_ARKTYPE_RULE
     }
 };
 /**
@@ -18111,10 +18606,14 @@ function _unsupported_iterable_to_array(o, minLen) {
  */ var firebaseESLintPlugin = FIREBASE_ESLINT_PLUGIN;
 
 exports.API_DETAILS_IMPORT_MODULE = API_DETAILS_IMPORT_MODULE;
+exports.CLEARABLE_FUNCTION_NAME = CLEARABLE_FUNCTION_NAME;
+exports.CLEARABLE_IMPORT_MODULE = CLEARABLE_IMPORT_MODULE;
 exports.DBX_MODEL_API_PARAMS_MARKER = DBX_MODEL_API_PARAMS_MARKER;
 exports.DBX_MODEL_FIREBASE_INDEX_MARKER = DBX_MODEL_FIREBASE_INDEX_MARKER;
 exports.DBX_MODEL_SERVICE_FACTORY_TAG = DBX_MODEL_SERVICE_FACTORY_TAG;
 exports.DEFAULT_API_DETAILS_FACTORY_NAME = DEFAULT_API_DETAILS_FACTORY_NAME;
+exports.DEFAULT_ARKTYPE_COMBINATOR_METHOD_NAMES = DEFAULT_ARKTYPE_COMBINATOR_METHOD_NAMES;
+exports.DEFAULT_ARKTYPE_DEFINITION_CALLEE_NAMES = DEFAULT_ARKTYPE_DEFINITION_CALLEE_NAMES;
 exports.DEFAULT_CONSTRAINT_FACTORY_NAMES = DEFAULT_CONSTRAINT_FACTORY_NAMES;
 exports.DEFAULT_CRUD_FUNCTIONS_CONFIG_SUFFIX = DEFAULT_CRUD_FUNCTIONS_CONFIG_SUFFIX;
 exports.DEFAULT_CRUD_FUNCTION_TYPE_VERBS = DEFAULT_CRUD_FUNCTION_TYPE_VERBS;
@@ -18138,6 +18637,7 @@ exports.FIREBASE_ESLINT_PLUGIN = FIREBASE_ESLINT_PLUGIN;
 exports.FIREBASE_MODEL_SERVICE_FACTORY_MODULE = FIREBASE_MODEL_SERVICE_FACTORY_MODULE;
 exports.FIREBASE_MODEL_SERVICE_FACTORY_NAME = FIREBASE_MODEL_SERVICE_FACTORY_NAME;
 exports.FIREBASE_MODULE = FIREBASE_MODULE;
+exports.FIREBASE_PREFER_CLEARABLE_ARKTYPE_RULE = FIREBASE_PREFER_CLEARABLE_ARKTYPE_RULE;
 exports.FIREBASE_REQUIRE_API_CRUD_SPEC_FOR_GROUP_RULE = FIREBASE_REQUIRE_API_CRUD_SPEC_FOR_GROUP_RULE;
 exports.FIREBASE_REQUIRE_API_DETAILS_FOR_CRUD_FUNCTION_RULE = FIREBASE_REQUIRE_API_DETAILS_FOR_CRUD_FUNCTION_RULE;
 exports.FIREBASE_REQUIRE_CANONICAL_API_SPEC_FILENAME_RULE = FIREBASE_REQUIRE_CANONICAL_API_SPEC_FILENAME_RULE;