@base44-preview/cli 0.1.7-pr.559.bb696d5 → 0.1.7-pr.584.aff66d4

package/dist/cli/index.js

@@ -119578,11 +119578,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema15 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema15);
+  const schema13 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema13);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema15, Schema2.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema13, Schema2.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -122922,9 +122922,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema15, utils3) => optionInfo.exception(value) || schema15.validate(value, utils3);
+    parameters.validate = (value, schema13, utils3) => optionInfo.exception(value) || schema13.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema15, utils3) => value === undefined || schema15.validate(value, utils3);
+    parameters.validate = (value, schema13, utils3) => value === undefined || schema13.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -122939,7 +122939,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema15, utils3) => schema15.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema13, utils3) => schema13.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -124516,9 +124516,9 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema15 = this._utils.schemas[key2];
+      const schema13 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema15.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema13.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -124529,13 +124529,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema15 = this._utils.schemas[key2];
+      const schema13 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema15.postprocess(value, this._utils);
+      const newValue = schema13.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema15);
+      this._applyValidation(newValue, key2, schema13);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -124546,14 +124546,14 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema15 = this._utils.schemas[key2];
-      const value = schema15.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema15);
+      const schema13 = this._utils.schemas[key2];
+      const value = schema13.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema13);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema15.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema13.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -124571,13 +124571,13 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema15.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema13.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema15.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema13.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema15.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema13.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -124605,8 +124605,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
     const [knownKeys, unknownKeys] = partition(Object.keys(options8).filter((key2) => !this._identifyMissing(key2, options8)), (key2) => (key2 in this._utils.schemas));
     return { knownKeys, unknownKeys };
   }
-  _applyValidation(value, key2, schema15) {
-    const validateResult = normalizeValidateResult(schema15.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema13) {
+    const validateResult = normalizeValidateResult(schema13.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -124648,8 +124648,8 @@ var require2, __filename2, __dirname3, __create2, __defProp3, __getOwnPropDesc2,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema15 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema15);
+          const schema13 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema13);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -138362,23 +138362,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema15) => {
-    const parent = schema15[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema13) => {
+    const parent = schema13[exports.Parent];
     if (!parent) {
-      return schema15;
+      return schema13;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema15) {
-    return schema15 === true || schema15 === false;
+  function isBoolean(schema13) {
+    return schema13 === true || schema13 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema15) {
-    return !(0, lodash_1.isPlainObject)(schema15);
+  function isPrimitive(schema13) {
+    return !(0, lodash_1.isPlainObject)(schema13);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema15) {
-    return Array.isArray(schema15.type) || "anyOf" in schema15 || "oneOf" in schema15;
+  function isCompound(schema13) {
+    return Array.isArray(schema13.type) || "anyOf" in schema13 || "oneOf" in schema13;
   }
   exports.isCompound = isCompound;
 });
@@ -138605,9 +138605,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema5 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema15, name2) {
+  function compileList(schema13, name2) {
     var result = [];
-    schema15[name2].forEach(function(currentType) {
+    schema13[name2].forEach(function(currentType) {
       var newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -140552,7 +140552,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema15, map2) {
+  function compileStyleMap(schema13, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -140564,7 +140564,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema15.compiledTypeMap["fallback"][tag];
+      type = schema13.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -141223,11 +141223,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema15, callback, processed) {
-    if (typeof schema15 !== "object" || !schema15) {
+  function traverseIntersection(schema13, callback, processed) {
+    if (typeof schema13 !== "object" || !schema13) {
       return;
     }
-    const r5 = schema15;
+    const r5 = schema13;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -141236,60 +141236,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema15, callback, processed = new Set, key2) {
-    if (processed.has(schema15)) {
+  function traverse(schema13, callback, processed = new Set, key2) {
+    if (processed.has(schema13)) {
       return;
     }
-    processed.add(schema15);
-    callback(schema15, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema15.anyOf) {
-      traverseArray(schema15.anyOf, callback, processed);
+    processed.add(schema13);
+    callback(schema13, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema13.anyOf) {
+      traverseArray(schema13.anyOf, callback, processed);
     }
-    if (schema15.allOf) {
-      traverseArray(schema15.allOf, callback, processed);
+    if (schema13.allOf) {
+      traverseArray(schema13.allOf, callback, processed);
     }
-    if (schema15.oneOf) {
-      traverseArray(schema15.oneOf, callback, processed);
+    if (schema13.oneOf) {
+      traverseArray(schema13.oneOf, callback, processed);
     }
-    if (schema15.properties) {
-      traverseObjectKeys(schema15.properties, callback, processed);
+    if (schema13.properties) {
+      traverseObjectKeys(schema13.properties, callback, processed);
     }
-    if (schema15.patternProperties) {
-      traverseObjectKeys(schema15.patternProperties, callback, processed);
+    if (schema13.patternProperties) {
+      traverseObjectKeys(schema13.patternProperties, callback, processed);
     }
-    if (schema15.additionalProperties && typeof schema15.additionalProperties === "object") {
-      traverse(schema15.additionalProperties, callback, processed);
+    if (schema13.additionalProperties && typeof schema13.additionalProperties === "object") {
+      traverse(schema13.additionalProperties, callback, processed);
     }
-    if (schema15.items) {
-      const { items } = schema15;
+    if (schema13.items) {
+      const { items } = schema13;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema15.additionalItems && typeof schema15.additionalItems === "object") {
-      traverse(schema15.additionalItems, callback, processed);
+    if (schema13.additionalItems && typeof schema13.additionalItems === "object") {
+      traverse(schema13.additionalItems, callback, processed);
     }
-    if (schema15.dependencies) {
-      if (Array.isArray(schema15.dependencies)) {
-        traverseArray(schema15.dependencies, callback, processed);
+    if (schema13.dependencies) {
+      if (Array.isArray(schema13.dependencies)) {
+        traverseArray(schema13.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema15.dependencies, callback, processed);
+        traverseObjectKeys(schema13.dependencies, callback, processed);
       }
     }
-    if (schema15.definitions) {
-      traverseObjectKeys(schema15.definitions, callback, processed);
+    if (schema13.definitions) {
+      traverseObjectKeys(schema13.definitions, callback, processed);
     }
-    if (schema15.$defs) {
-      traverseObjectKeys(schema15.$defs, callback, processed);
+    if (schema13.$defs) {
+      traverseObjectKeys(schema13.$defs, callback, processed);
     }
-    if (schema15.not) {
-      traverse(schema15.not, callback, processed);
+    if (schema13.not) {
+      traverse(schema13.not, callback, processed);
     }
-    traverseIntersection(schema15, callback, processed);
-    Object.keys(schema15).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema15[key3];
+    traverseIntersection(schema13, callback, processed);
+    Object.keys(schema13).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema13[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -141371,14 +141371,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema15) {
+  function escapeBlockComment(schema13) {
     const replacer = "* /";
-    if (schema15 === null || typeof schema15 !== "object") {
+    if (schema13 === null || typeof schema13 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema15)) {
-      if (key2 === "description" && typeof schema15[key2] === "string") {
-        schema15[key2] = schema15[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema13)) {
+      if (key2 === "description" && typeof schema13[key2] === "string") {
+        schema13[key2] = schema13[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -141390,45 +141390,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema15) {
-    if (!("default" in schema15)) {
-      return schema15;
+  function maybeStripDefault(schema13) {
+    if (!("default" in schema13)) {
+      return schema13;
     }
-    switch (schema15.type) {
+    switch (schema13.type) {
       case "array":
-        if (Array.isArray(schema15.default)) {
-          return schema15;
+        if (Array.isArray(schema13.default)) {
+          return schema13;
         }
         break;
       case "boolean":
-        if (typeof schema15.default === "boolean") {
-          return schema15;
+        if (typeof schema13.default === "boolean") {
+          return schema13;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema15.default === "number") {
-          return schema15;
+        if (typeof schema13.default === "number") {
+          return schema13;
         }
         break;
       case "string":
-        if (typeof schema15.default === "string") {
-          return schema15;
+        if (typeof schema13.default === "string") {
+          return schema13;
         }
         break;
       case "null":
-        if (schema15.default === null) {
-          return schema15;
+        if (schema13.default === null) {
+          return schema13;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema15.default)) {
-          return schema15;
+        if ((0, lodash_1.isPlainObject)(schema13.default)) {
+          return schema13;
         }
         break;
     }
-    delete schema15.default;
-    return schema15;
+    delete schema13.default;
+    return schema13;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -141442,11 +141442,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema15) {
-    if (!(0, lodash_1.isPlainObject)(schema15)) {
+  function isSchemaLike(schema13) {
+    if (!(0, lodash_1.isPlainObject)(schema13)) {
       return false;
     }
-    const parent = schema15[JSONSchema_1.Parent];
+    const parent = schema13[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -141463,7 +141463,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema15)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema13)) {
       return false;
     }
     return true;
@@ -141761,13 +141761,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash8();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema15) {
-    if (schema15.tsType) {
+  function typesOfSchema(schema13) {
+    if (schema13.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema15)) {
+      if (f7(schema13)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -141778,26 +141778,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema15) {
-      return "allOf" in schema15;
+    ALL_OF(schema13) {
+      return "allOf" in schema13;
     },
-    ANY(schema15) {
-      if (Object.keys(schema15).length === 0) {
+    ANY(schema13) {
+      if (Object.keys(schema13).length === 0) {
         return true;
       }
-      return schema15.type === "any";
+      return schema13.type === "any";
     },
-    ANY_OF(schema15) {
-      return "anyOf" in schema15;
+    ANY_OF(schema13) {
+      return "anyOf" in schema13;
     },
-    BOOLEAN(schema15) {
-      if ("enum" in schema15) {
+    BOOLEAN(schema13) {
+      if ("enum" in schema13) {
         return false;
       }
-      if (schema15.type === "boolean") {
+      if (schema13.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema15) && typeof schema15.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "boolean") {
         return true;
       }
       return false;
@@ -141805,74 +141805,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema15) {
-      return "enum" in schema15 && "tsEnumNames" in schema15;
+    NAMED_ENUM(schema13) {
+      return "enum" in schema13 && "tsEnumNames" in schema13;
     },
-    NAMED_SCHEMA(schema15) {
-      return "$id" in schema15 && (("patternProperties" in schema15) || ("properties" in schema15));
+    NAMED_SCHEMA(schema13) {
+      return "$id" in schema13 && (("patternProperties" in schema13) || ("properties" in schema13));
     },
-    NEVER(schema15) {
-      return schema15 === false;
+    NEVER(schema13) {
+      return schema13 === false;
     },
-    NULL(schema15) {
-      return schema15.type === "null";
+    NULL(schema13) {
+      return schema13.type === "null";
     },
-    NUMBER(schema15) {
-      if ("enum" in schema15) {
+    NUMBER(schema13) {
+      if ("enum" in schema13) {
         return false;
       }
-      if (schema15.type === "integer" || schema15.type === "number") {
+      if (schema13.type === "integer" || schema13.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema15) && typeof schema15.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema15) {
-      return schema15.type === "object" && !(0, lodash_1.isPlainObject)(schema15.additionalProperties) && !schema15.allOf && !schema15.anyOf && !schema15.oneOf && !schema15.patternProperties && !schema15.properties && !schema15.required;
+    OBJECT(schema13) {
+      return schema13.type === "object" && !(0, lodash_1.isPlainObject)(schema13.additionalProperties) && !schema13.allOf && !schema13.anyOf && !schema13.oneOf && !schema13.patternProperties && !schema13.properties && !schema13.required;
     },
-    ONE_OF(schema15) {
-      return "oneOf" in schema15;
+    ONE_OF(schema13) {
+      return "oneOf" in schema13;
     },
-    REFERENCE(schema15) {
-      return "$ref" in schema15;
+    REFERENCE(schema13) {
+      return "$ref" in schema13;
     },
-    STRING(schema15) {
-      if ("enum" in schema15) {
+    STRING(schema13) {
+      if ("enum" in schema13) {
         return false;
       }
-      if (schema15.type === "string") {
+      if (schema13.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema15) && typeof schema15.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema13) && typeof schema13.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema15) {
-      if (schema15.type && schema15.type !== "array") {
+    TYPED_ARRAY(schema13) {
+      if (schema13.type && schema13.type !== "array") {
         return false;
       }
-      return "items" in schema15;
+      return "items" in schema13;
     },
-    UNION(schema15) {
-      return Array.isArray(schema15.type);
+    UNION(schema13) {
+      return Array.isArray(schema13.type);
     },
-    UNNAMED_ENUM(schema15) {
-      if ("tsEnumNames" in schema15) {
+    UNNAMED_ENUM(schema13) {
+      if ("tsEnumNames" in schema13) {
         return false;
       }
-      if (schema15.type && schema15.type !== "boolean" && schema15.type !== "integer" && schema15.type !== "number" && schema15.type !== "string") {
+      if (schema13.type && schema13.type !== "boolean" && schema13.type !== "integer" && schema13.type !== "number" && schema13.type !== "string") {
         return false;
       }
-      return "enum" in schema15;
+      return "enum" in schema13;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema15) {
-      return schema15.type === "array" && !("items" in schema15);
+    UNTYPED_ARRAY(schema13) {
+      return schema13.type === "array" && !("items" in schema13);
     }
   };
 });
@@ -141883,10 +141883,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema15) {
+  function applySchemaTyping(schema13) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema15);
-    Object.defineProperty(schema15, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema13);
+    Object.defineProperty(schema13, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -141895,23 +141895,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema15,
+      [JSONSchema_1.Parent]: schema13,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema15.$id,
-      description: schema15.description,
-      name: schema15.name,
-      title: schema15.title,
-      allOf: (_a7 = schema15.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema13.$id,
+      description: schema13.description,
+      name: schema13.name,
+      title: schema13.title,
+      allOf: (_a7 = schema13.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema15.allOf;
-    delete schema15.$id;
-    delete schema15.description;
-    delete schema15.name;
-    delete schema15.title;
-    Object.defineProperty(schema15, JSONSchema_1.Intersection, {
+    delete schema13.allOf;
+    delete schema13.$id;
+    delete schema13.description;
+    delete schema13.name;
+    delete schema13.title;
+    Object.defineProperty(schema13, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -141929,186 +141929,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema15, type) {
-    return schema15.type === type || Array.isArray(schema15.type) && schema15.type.includes(type);
+  function hasType(schema13, type) {
+    return schema13.type === type || Array.isArray(schema13.type) && schema13.type.includes(type);
   }
-  function isObjectType(schema15) {
-    return schema15.properties !== undefined || hasType(schema15, "object") || hasType(schema15, "any");
+  function isObjectType(schema13) {
+    return schema13.properties !== undefined || hasType(schema13, "object") || hasType(schema13, "any");
   }
-  function isArrayType(schema15) {
-    return schema15.items !== undefined || hasType(schema15, "array") || hasType(schema15, "any");
+  function isArrayType(schema13) {
+    return schema13.items !== undefined || hasType(schema13, "array") || hasType(schema13, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema15) {
-    return schema15.type === "string" && schema15.enum !== undefined && schema15.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema13) {
+    return schema13.type === "string" && schema13.enum !== undefined && schema13.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema15) => {
-    if (Array.isArray(schema15.enum) && schema15.enum.some((e8) => e8 === null) && Array.isArray(schema15.type) && schema15.type.includes("null")) {
-      schema15.type = schema15.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema13) => {
+    if (Array.isArray(schema13.enum) && schema13.enum.some((e8) => e8 === null) && Array.isArray(schema13.type) && schema13.type.includes("null")) {
+      schema13.type = schema13.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema15) => {
-    if (schema15.type && Array.isArray(schema15.type) && schema15.type.length === 1) {
-      schema15.type = schema15.type[0];
+  rules.set("Destructure unary types", (schema13) => {
+    if (schema13.type && Array.isArray(schema13.type) && schema13.type.length === 1) {
+      schema13.type = schema13.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema15) => {
-    if (isObjectType(schema15) && !("required" in schema15)) {
-      schema15.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema13) => {
+    if (isObjectType(schema13) && !("required" in schema13)) {
+      schema13.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema15) => {
-    if (schema15.required === false) {
-      schema15.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema13) => {
+    if (schema13.required === false) {
+      schema13.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema15, _10, options8) => {
-    if (isObjectType(schema15) && !("additionalProperties" in schema15) && schema15.patternProperties === undefined) {
-      schema15.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema13, _10, options8) => {
+    if (isObjectType(schema13) && !("additionalProperties" in schema13) && schema13.patternProperties === undefined) {
+      schema13.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema15, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema15)) {
+  rules.set("Transform id to $id", (schema13, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema13)) {
       return;
     }
-    if (schema15.id && schema15.$id && schema15.id !== schema15.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema15.id}, $id=${schema15.$id} in ${fileName}`);
+    if (schema13.id && schema13.$id && schema13.id !== schema13.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema13.id}, $id=${schema13.$id} in ${fileName}`);
     }
-    if (schema15.id) {
-      schema15.$id = schema15.id;
-      delete schema15.id;
+    if (schema13.id) {
+      schema13.$id = schema13.id;
+      delete schema13.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema15, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema15)) {
+  rules.set("Add an $id to anything that needs it", (schema13, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema13)) {
       return;
     }
-    if (!schema15.$id && !schema15[JSONSchema_1.Parent]) {
-      schema15.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema13.$id && !schema13[JSONSchema_1.Parent]) {
+      schema13.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema15) && !isObjectType(schema15)) {
+    if (!isArrayType(schema13) && !isObjectType(schema13)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema15);
-    if (!schema15.$id && !schema15.title && dereferencedName) {
-      schema15.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema13);
+    if (!schema13.$id && !schema13.title && dereferencedName) {
+      schema13.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema15);
+      dereferencedPaths.delete(schema13);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema15) => {
-    (0, utils_1.escapeBlockComment)(schema15);
+  rules.set("Escape closing JSDoc comment", (schema13) => {
+    (0, utils_1.escapeBlockComment)(schema13);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema15) => {
-    if (!isArrayType(schema15)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema13) => {
+    if (!isArrayType(schema13)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema15 ? `@minItems ${schema15.minItems}` : "",
-      "maxItems" in schema15 ? `@maxItems ${schema15.maxItems}` : ""
+      "minItems" in schema13 ? `@minItems ${schema13.minItems}` : "",
+      "maxItems" in schema13 ? `@maxItems ${schema13.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema15.description = (0, utils_1.appendToDescription)(schema15.description, ...commentsToAppend);
+      schema13.description = (0, utils_1.appendToDescription)(schema13.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema15, _fileName, options8) => {
-    if (!isArrayType(schema15)) {
+  rules.set("Optionally remove maxItems and minItems", (schema13, _fileName, options8) => {
+    if (!isArrayType(schema13)) {
       return;
     }
-    if ("minItems" in schema15 && options8.ignoreMinAndMaxItems) {
-      delete schema15.minItems;
+    if ("minItems" in schema13 && options8.ignoreMinAndMaxItems) {
+      delete schema13.minItems;
     }
-    if ("maxItems" in schema15 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema15.maxItems;
+    if ("maxItems" in schema13 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema13.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema15, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema13, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema15)) {
+    if (!isArrayType(schema13)) {
       return;
     }
-    const { minItems } = schema15;
-    schema15.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema13;
+    schema13.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema15, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema13, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema15)) {
+    if (!isArrayType(schema13)) {
       return;
     }
-    const { maxItems, minItems } = schema15;
+    const { maxItems, minItems } = schema13;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema15.maxItems;
+      delete schema13.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema15, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema13, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema15;
+    const { maxItems, minItems } = schema13;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema15.items && !Array.isArray(schema15.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema15.items;
+    if (schema13.items && !Array.isArray(schema13.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema13.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema15.additionalItems = items;
+        schema13.additionalItems = items;
       }
-      schema15.items = newItems;
+      schema13.items = newItems;
     }
-    if (Array.isArray(schema15.items) && hasMaxItems && maxItems < schema15.items.length) {
-      schema15.items = schema15.items.slice(0, maxItems);
+    if (Array.isArray(schema13.items) && hasMaxItems && maxItems < schema13.items.length) {
+      schema13.items = schema13.items.slice(0, maxItems);
     }
-    return schema15;
+    return schema13;
   });
-  rules.set("Remove extends, if it is empty", (schema15) => {
-    if (!schema15.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema13) => {
+    if (!schema13.hasOwnProperty("extends")) {
       return;
     }
-    if (schema15.extends == null || Array.isArray(schema15.extends) && schema15.extends.length === 0) {
-      delete schema15.extends;
+    if (schema13.extends == null || Array.isArray(schema13.extends) && schema13.extends.length === 0) {
+      delete schema13.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema15) => {
-    if (schema15.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema13) => {
+    if (schema13.extends == null) {
       return;
     }
-    if (!Array.isArray(schema15.extends)) {
-      schema15.extends = [schema15.extends];
+    if (!Array.isArray(schema13.extends)) {
+      schema13.extends = [schema13.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema15, fileName) => {
-    if (schema15.definitions && schema15.$defs && !(0, util_1.isDeepStrictEqual)(schema15.definitions, schema15.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema15.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema13, fileName) => {
+    if (schema13.definitions && schema13.$defs && !(0, util_1.isDeepStrictEqual)(schema13.definitions, schema13.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema13.id} in ${fileName}`);
     }
-    if (schema15.definitions) {
-      schema15.$defs = schema15.definitions;
-      delete schema15.definitions;
+    if (schema13.definitions) {
+      schema13.$defs = schema13.definitions;
+      delete schema13.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema15) => {
-    if (schema15.const !== undefined) {
-      schema15.enum = [schema15.const];
-      delete schema15.const;
+  rules.set("Transform const to singleton enum", (schema13) => {
+    if (schema13.const !== undefined) {
+      schema13.enum = [schema13.const];
+      delete schema13.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema15, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema13, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema15) && options8.inferStringEnumKeysFromValues) {
-      schema15.tsEnumNames = (_a7 = schema15.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema13) && options8.inferStringEnumKeysFromValues) {
+      schema13.tsEnumNames = (_a7 = schema13.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema15) => {
-    if (schema15 !== null && typeof schema15 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema15);
+  rules.set("Pre-calculate schema types and intersections", (schema13) => {
+    if (schema13 !== null && typeof schema13 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema13);
     }
   });
   function normalize2(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema15, key2) => rule(schema15, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema13, key2) => rule(schema13, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize2;
@@ -142190,37 +142190,37 @@ var require_parser2 = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse11(schema15, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema15)) {
-      if ((0, JSONSchema_1.isBoolean)(schema15)) {
-        return parseBooleanSchema(schema15, keyName, options8);
+  function parse11(schema13, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema13)) {
+      if ((0, JSONSchema_1.isBoolean)(schema13)) {
+        return parseBooleanSchema(schema13, keyName, options8);
       }
-      return parseLiteral(schema15, keyName);
+      return parseLiteral(schema13, keyName);
     }
-    const intersection2 = schema15[JSONSchema_1.Intersection];
-    const types = schema15[JSONSchema_1.Types];
+    const intersection2 = schema13[JSONSchema_1.Intersection];
+    const types = schema13[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema15, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema13, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema15, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema13, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema15, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema15, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema13, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema13, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse11;
-  function parseAsTypeWithCache(schema15, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema15);
+  function parseAsTypeWithCache(schema13, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema13);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema15, cachedTypeMap);
+      processed.set(schema13, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -142228,10 +142228,10 @@ var require_parser2 = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema15, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema13, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema15, keyName, options8) {
-    if (schema15) {
+  function parseBooleanSchema(schema13, keyName, options8) {
+    if (schema13) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -142242,157 +142242,157 @@ var require_parser2 = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema15, keyName) {
+  function parseLiteral(schema13, keyName) {
     return {
       keyName,
-      params: schema15,
+      params: schema13,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema15, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema15));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema15);
+  function parseNonLiteral(schema13, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema13));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema13);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-          params: schema15.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.allOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "INTERSECTION"
         };
       case "ANY":
-        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema15.description, deprecated: schema15.deprecated, keyName, standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema13.description, deprecated: schema13.deprecated, keyName, standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-          params: schema15.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.anyOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          params: schema15.tsType,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          params: schema13.tsType,
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema15.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema13, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema13.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema15.tsEnumNames[n5]
+            keyName: schema13.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema15, options8, processed, usedNames, keyName);
+        return newInterface(schema13, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema15.description,
+          comment: schema13.description,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema15.deprecated
+          deprecated: schema13.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-          params: schema15.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.oneOf.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "REFERENCE":
-        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema15));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema13));
       case "STRING":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema15.items)) {
-          const minItems2 = schema15.minItems;
-          const maxItems2 = schema15.maxItems;
+        if (Array.isArray(schema13.items)) {
+          const minItems2 = schema13.minItems;
+          const maxItems2 = schema13.maxItems;
           const arrayType = {
-            comment: schema15.description,
-            deprecated: schema15.deprecated,
+            comment: schema13.description,
+            deprecated: schema13.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-            params: schema15.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+            params: schema13.items.map((_10) => parse11(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema15.additionalItems === true) {
+          if (schema13.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema15.additionalItems) {
-            arrayType.spreadParam = parse11(schema15.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema13.additionalItems) {
+            arrayType.spreadParam = parse11(schema13.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema15.description,
-            deprecated: schema15.deprecated,
+            comment: schema13.description,
+            deprecated: schema13.deprecated,
             keyName,
-            standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-            params: parse11(schema15.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+            params: parse11(schema13.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-          params: schema15.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema15, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema13, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse11(member, options8, undefined, processed, usedNames);
@@ -142401,80 +142401,80 @@ var require_parser2 = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
-          params: schema15.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
+          params: schema13.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema15, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema13, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema15.minItems;
-        const maxItems = typeof schema15.maxItems === "number" ? schema15.maxItems : -1;
+        const minItems = schema13.minItems;
+        const maxItems = typeof schema13.maxItems === "number" ? schema13.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema15.description,
-            deprecated: schema15.deprecated,
+            comment: schema13.description,
+            deprecated: schema13.deprecated,
             keyName,
-            maxItems: schema15.maxItems,
+            maxItems: schema13.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema15.description,
-          deprecated: schema15.deprecated,
+          comment: schema13.description,
+          deprecated: schema13.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema15, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema13, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema15, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema13, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema15, keyNameFromDefinition)) || schema15.title || schema15.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema13, keyNameFromDefinition)) || schema13.title || schema13.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema15, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema15, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema13, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema13, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema15.description,
-      deprecated: schema15.deprecated,
+      comment: schema13.description,
+      deprecated: schema13.deprecated,
       keyName,
-      params: parseSchema(schema15, options8, processed, usedNames, name2),
+      params: parseSchema(schema13, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema15, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema13, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema15, options8, processed, usedNames) {
-    const superTypes = schema15.extends;
+  function parseSuperTypes(schema13, options8, processed, usedNames) {
+    const superTypes = schema13.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse11(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema15, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema15.properties, (value, key2) => ({
+  function parseSchema(schema13, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema13.properties, (value, key2) => ({
       ast: parse11(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema15.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema13.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema15.patternProperties) {
-      singlePatternProperty = !schema15.additionalProperties && Object.keys(schema15.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema15.patternProperties, (value, key2) => {
+    if (schema13.patternProperties) {
+      singlePatternProperty = !schema13.additionalProperties && Object.keys(schema13.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema13.patternProperties, (value, key2) => {
         const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key2.replace("*/", "*\\/")}".`;
@@ -142484,14 +142484,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema15.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema13.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema15.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema13.$defs, (value, key2) => {
         const ast = parse11(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key2}".`;
@@ -142501,13 +142501,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema15.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema13.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema15.additionalProperties) {
+    switch (schema13.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -142524,7 +142524,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse11(schema15.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse11(schema13.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -142532,22 +142532,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema15, isSchema = true, processed = new Set) {
-    if (processed.has(schema15)) {
+  function getDefinitions(schema13, isSchema = true, processed = new Set) {
+    if (processed.has(schema13)) {
       return {};
     }
-    processed.add(schema15);
-    if (Array.isArray(schema15)) {
-      return schema15.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema13);
+    if (Array.isArray(schema13)) {
+      return schema13.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema15)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema15) ? schema15.$defs : {}), Object.keys(schema15).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema15[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema13)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema13) ? schema13.$defs : {}), Object.keys(schema13).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema13[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema15) {
-    return "$defs" in schema15;
+  function hasDefinitions(schema13) {
+    return "$defs" in schema13;
   }
 });
 
@@ -143233,14 +143233,14 @@ var require_errors2 = __commonJS((exports) => {
   }
   exports.MissingPointerError = MissingPointerError;
 
-  class TimeoutError4 extends JSONParserError {
+  class TimeoutError3 extends JSONParserError {
     constructor(timeout2) {
       super(`Dereferencing timeout reached: ${timeout2}ms`);
       this.code = "ETIMEOUT";
       this.name = "TimeoutError";
     }
   }
-  exports.TimeoutError = TimeoutError4;
+  exports.TimeoutError = TimeoutError3;
 
   class InvalidPointerError extends JSONParserError {
     constructor(pointer, path18) {
@@ -144371,7 +144371,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema15;
+    let schema13;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -144381,15 +144381,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema15 = args[1];
+        schema13 = args[1];
         options8 = args[2];
       } else {
-        schema15 = undefined;
+        schema13 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema15 = args[0];
+      schema13 = args[0];
       options8 = args[1];
     }
     try {
@@ -144397,12 +144397,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema15 === "object") {
-      schema15 = JSON.parse(JSON.stringify(schema15));
+    if (!options8.mutateInputSchema && typeof schema13 === "object") {
+      schema13 = JSON.parse(JSON.stringify(schema13));
     }
     return {
       path: path18,
-      schema: schema15,
+      schema: schema13,
       options: options8,
       callback
     };
@@ -145191,12 +145191,12 @@ var require_resolver = __commonJS((exports) => {
   var json_schema_ref_parser_1 = require_lib3();
   var utils_1 = require_utils7();
   function dereference(schema_1, _a7) {
-    return __awaiter(this, arguments, undefined, function* (schema15, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema15);
+    return __awaiter(this, arguments, undefined, function* (schema13, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema13);
       const parser2 = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser2.dereference(cwd, schema15, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema16) {
-        dereferencedPaths.set(schema16, $ref);
+      const dereferencedSchema = yield parser2.dereference(cwd, schema13, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema14) {
+        dereferencedPaths.set(schema14, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -145210,46 +145210,46 @@ var require_validator = __commonJS((exports) => {
   exports.validate = undefined;
   var utils_1 = require_utils7();
   var rules = new Map;
-  rules.set("Enum members and tsEnumNames must be of the same length", (schema15) => {
-    if (schema15.enum && schema15.tsEnumNames && schema15.enum.length !== schema15.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema13) => {
+    if (schema13.enum && schema13.tsEnumNames && schema13.enum.length !== schema13.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema15) => {
-    if (schema15.tsEnumNames && schema15.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema13) => {
+    if (schema13.tsEnumNames && schema13.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema15) => {
-    const { maxItems, minItems } = schema15;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema13) => {
+    const { maxItems, minItems } = schema13;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema15) => {
-    const { maxItems } = schema15;
+  rules.set("When maxItems exists, maxItems >= 0", (schema13) => {
+    const { maxItems } = schema13;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema15) => {
-    const { minItems } = schema15;
+  rules.set("When minItems exists, minItems >= 0", (schema13) => {
+    const { minItems } = schema13;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema15) => {
-    const typeOfDeprecated = typeof schema15.deprecated;
+  rules.set("deprecated must be a boolean", (schema13) => {
+    const typeOfDeprecated = typeof schema13.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema15, filename) {
+  function validate2(schema13, filename) {
     const errors5 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema15, (schema16, key2) => {
-        if (rule(schema16) === false) {
+      (0, utils_1.traverse)(schema13, (schema14, key2) => {
+        if (rule(schema14) === false) {
           errors5.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema16;
+        return schema14;
       });
     });
     return errors5;
@@ -145263,25 +145263,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash8();
-  function link2(schema15, parent = null) {
-    if (!Array.isArray(schema15) && !(0, lodash_1.isPlainObject)(schema15)) {
-      return schema15;
+  function link2(schema13, parent = null) {
+    if (!Array.isArray(schema13) && !(0, lodash_1.isPlainObject)(schema13)) {
+      return schema13;
     }
-    if (schema15.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema15;
+    if (schema13.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema13;
     }
-    Object.defineProperty(schema15, JSONSchema_1.Parent, {
+    Object.defineProperty(schema13, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema15)) {
-      schema15.forEach((child) => link2(child, schema15));
+    if (Array.isArray(schema13)) {
+      schema13.forEach((child) => link2(child, schema13));
     }
-    for (const key2 in schema15) {
-      link2(schema15[key2], schema15);
+    for (const key2 in schema13) {
+      link2(schema13[key2], schema13);
     }
-    return schema15;
+    return schema13;
   }
   exports.link = link2;
 });
@@ -145373,8 +145373,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema15 = parseAsJSONSchema(filename);
-    return compile(schema15, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema13 = parseAsJSONSchema(filename);
+    return compile(schema13, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -145384,7 +145384,7 @@ var require_src3 = __commonJS((exports) => {
     return (0, utils_1.parseFileAsJSONSchema)(filename, contents.toString());
   }
   function compile(schema_1, name_1) {
-    return __awaiter(this, arguments, undefined, function* (schema15, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema13, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -145394,7 +145394,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema15);
+      const _schema = (0, lodash_1.cloneDeep)(schema13);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -236729,10 +236729,6 @@ class InvalidInputError extends UserError {
   code = "INVALID_INPUT";
 }
 
-class TimeoutError2 extends UserError {
-  code = "TIMEOUT";
-}
-
 class DependencyNotFoundError extends UserError {
   code = "DEPENDENCY_NOT_FOUND";
   constructor(message, options) {
@@ -238925,7 +238921,7 @@ var createTimeoutError = (timeout2) => {
     return timeout2.message;
   }
   const message = timeout2.message ?? `Promise timed out after ${timeout2.milliseconds} milliseconds`;
-  return new TimeoutError3(message);
+  return new TimeoutError2(message);
 };
 var handleFallback = (timeout2) => {
   if (timeout2.fallback) {
@@ -238938,7 +238934,7 @@ var handleAbortError = (timeoutSignal, timeout2, signal) => {
     if (typeof timeout2 === "object") {
       return handleFallback(timeout2);
     }
-    throw new TimeoutError3;
+    throw new TimeoutError2;
   }
   throw signal.reason;
 };
@@ -238983,7 +238979,7 @@ async function pWaitFor(condition, options = {}) {
 }
 pWaitFor.resolveWith = (value) => ({ [resolveValue]: value });
 
-class TimeoutError3 extends Error {
+class TimeoutError2 extends Error {
   constructor(message = "Promise timed out") {
     super(message);
     this.name = "TimeoutError";
@@ -255129,9 +255125,7 @@ var WRANGLER_REDIRECT_PATH = join16(".wrangler", "deploy", "config.json");
 var RedirectConfigSchema = exports_external.looseObject({
   configPath: exports_external.string().min(1)
 });
-var BindingArraySchema = exports_external.array(exports_external.unknown()).optional();
 var WranglerConfigSchema = exports_external.looseObject({
-  name: exports_external.string().optional(),
   main: exports_external.string().min(1, "wrangler config is missing a 'main' entry module"),
   no_bundle: exports_external.boolean().optional(),
   rules: exports_external.array(exports_external.looseObject({ type: exports_external.string(), globs: exports_external.array(exports_external.string()) })).optional(),
@@ -255146,19 +255140,7 @@ var WranglerConfigSchema = exports_external.looseObject({
   compatibility_date: exports_external.string().optional(),
   compatibility_flags: exports_external.array(exports_external.string()).optional(),
   vars: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
-  upload_source_maps: exports_external.boolean().optional(),
-  kv_namespaces: BindingArraySchema,
-  d1_databases: BindingArraySchema,
-  r2_buckets: BindingArraySchema,
-  durable_objects: exports_external.looseObject({ bindings: BindingArraySchema }).optional(),
-  services: BindingArraySchema,
-  queues: exports_external.looseObject({
-    producers: BindingArraySchema,
-    consumers: BindingArraySchema
-  }).optional(),
-  hyperdrive: BindingArraySchema,
-  analytics_engine_datasets: BindingArraySchema,
-  vectorize: BindingArraySchema
+  upload_source_maps: exports_external.boolean().optional()
 });
 async function detectFullStackArtifact(projectRoot) {
   const redirectPath = join16(projectRoot, WRANGLER_REDIRECT_PATH);
@@ -255197,13 +255179,11 @@ async function resolveWranglerConfig(projectRoot) {
   if (config12.no_bundle !== true) {
     throw new InvalidInputError("This framework's output requires bundling; not yet supported. Base44 full-stack deploys only support pre-bundled Workers output (no_bundle: true).");
   }
-  assertNoUnsupportedBindings(config12, configPath);
   const configDir = dirname10(configPath);
   const assetsDirectory = config12.assets?.directory ? resolve5(configDir, config12.assets.directory) : null;
   return {
     configPath,
     configDir,
-    name: config12.name ?? null,
     main: config12.main,
     assetsDirectory,
     assetsConfig: config12.assets ? toResolvedAssetsConfig(config12.assets) : null,
@@ -255240,26 +255220,6 @@ function toResolvedAssetsConfig(assets) {
     redirects: assets.redirects
   };
 }
-function assertNoUnsupportedBindings(config12, configPath) {
-  const bindingSources = {
-    kv_namespaces: config12.kv_namespaces,
-    d1_databases: config12.d1_databases,
-    r2_buckets: config12.r2_buckets,
-    "durable_objects.bindings": config12.durable_objects?.bindings,
-    services: config12.services,
-    "queues.producers": config12.queues?.producers,
-    "queues.consumers": config12.queues?.consumers,
-    hyperdrive: config12.hyperdrive,
-    analytics_engine_datasets: config12.analytics_engine_datasets,
-    vectorize: config12.vectorize
-  };
-  const used = Object.entries(bindingSources).filter(([, values]) => (values?.length ?? 0) > 0).map(([name2]) => name2);
-  if (used.length > 0) {
-    throw new InvalidInputError(`Unsupported bindings for Base44 full-stack deploys: ${used.join(", ")}. Remove them or file a feature request.`, {
-      hints: [{ message: `Edit the bindings in ${configPath}` }]
-    });
-  }
-}
 
 // src/core/deployments/deploy.ts
 async function resolveGitHash(projectRoot, explicit) {
@@ -256631,7 +256591,7 @@ async function runOAuthFlowWithSkip(connector2) {
       timeout: POLL_TIMEOUT_MS
     });
   } catch (err) {
-    if (err instanceof TimeoutError3) {
+    if (err instanceof TimeoutError2) {
       finalStatus = "PENDING";
     } else {
       throw err;
@@ -256971,214 +256931,6 @@ function getDashboardCommand() {
   return new Command("dashboard").description("Manage app dashboard").addCommand(getDashboardOpenCommand());
 }
 
-// src/core/domains/schema.ts
-var DomainVerificationSchema = exports_external.object({
-  ownership_verification: exports_external.unknown().nullable().optional(),
-  ownership_verification_http: exports_external.unknown().nullable().optional(),
-  ssl_validation_records: exports_external.array(exports_external.unknown()).nullable().optional(),
-  ssl_validation_errors: exports_external.array(exports_external.unknown()).nullable().optional()
-}).transform((data) => ({
-  ownershipVerification: data.ownership_verification ?? null,
-  ownershipVerificationHttp: data.ownership_verification_http ?? null,
-  sslValidationRecords: data.ssl_validation_records ?? null,
-  sslValidationErrors: data.ssl_validation_errors ?? null
-}));
-var DomainSchema = exports_external.object({
-  hostname: exports_external.string(),
-  cname_target: exports_external.string(),
-  status: exports_external.string().nullable(),
-  ssl_status: exports_external.string().nullable(),
-  active: exports_external.boolean(),
-  pending_deployment: exports_external.boolean().optional(),
-  verification: DomainVerificationSchema
-}).transform((data) => ({
-  hostname: data.hostname,
-  cnameTarget: data.cname_target,
-  status: data.status,
-  sslStatus: data.ssl_status,
-  active: data.active,
-  pendingDeployment: data.pending_deployment ?? false,
-  verification: data.verification
-}));
-var AddDomainResponseSchema = DomainSchema;
-var DomainsListResponseSchema = exports_external.object({ domains: exports_external.array(DomainSchema) }).transform((data) => data.domains);
-var RemoveDomainResponseSchema = exports_external.object({ hostname: exports_external.string(), deleted: exports_external.boolean() }).transform((data) => ({ hostname: data.hostname, deleted: data.deleted }));
-
-// src/core/domains/api.ts
-async function addDomain(hostname3) {
-  const appClient = getAppClient();
-  const request = { hostname: hostname3 };
-  let response;
-  try {
-    response = await appClient.post("domains", {
-      json: request,
-      timeout: 120000
-    });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "connecting domain");
-  }
-  const result = AddDomainResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-async function listDomains() {
-  const appClient = getAppClient();
-  let response;
-  try {
-    response = await appClient.get("domains");
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "listing domains");
-  }
-  const result = DomainsListResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-async function removeDomain(hostname3) {
-  const appClient = getAppClient();
-  let response;
-  try {
-    response = await appClient.delete(`domains/${encodeURIComponent(hostname3)}`);
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "removing domain");
-  }
-  const result = RemoveDomainResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-var delay2 = (ms) => new Promise((resolve10) => setTimeout(resolve10, ms));
-async function waitForDomainActive(hostname3, options = {}) {
-  const intervalMs = options.intervalMs ?? 2000;
-  const timeoutMs = options.timeoutMs ?? 10 * 60000;
-  const deadline = Date.now() + timeoutMs;
-  for (;; ) {
-    const domain2 = (await listDomains()).find((d2) => d2.hostname === hostname3);
-    options.onTick?.(domain2);
-    if (domain2?.active) {
-      return domain2;
-    }
-    if (Date.now() >= deadline) {
-      throw new TimeoutError2(`Timed out waiting for ${hostname3} to become active`);
-    }
-    await delay2(intervalMs);
-  }
-}
-// src/cli/commands/domains/shared.ts
-function toJsonStdout2(result) {
-  return `${JSON.stringify(result, null, 2)}
-`;
-}
-function domainStatusText(domain2) {
-  const status = domain2.status ?? "unknown";
-  const ssl = domain2.sslStatus ?? "unknown";
-  return domain2.active ? "active" : `${status} (SSL: ${ssl})`;
-}
-function formatDomainLine(domain2) {
-  const status = (domain2.active ? "active" : domain2.status ?? "unknown").padEnd(12);
-  const ssl = `ssl:${domain2.sslStatus ?? "unknown"}`.padEnd(22);
-  return `${domain2.hostname.padEnd(32)} ${status} ${ssl} → ${theme.colors.links(domain2.cnameTarget)}`;
-}
-function logDomainSetup(domain2, log) {
-  log.message(`${theme.styles.header("Add this DNS record")}:`);
-  log.message(`  CNAME  ${domain2.hostname}  ${theme.styles.dim("→")}  ${theme.colors.links(domain2.cnameTarget)}`);
-  log.message(`${theme.styles.header("Status")}: ${domainStatusText(domain2)}`);
-  if (domain2.pendingDeployment) {
-    log.warn("This app has no production deployment yet — the domain will start serving once the app is published.");
-  }
-  log.message(theme.styles.dim("TLS certificate is issued automatically once the CNAME resolves."));
-}
-
-// src/cli/commands/domains/add.ts
-function waitMessage(domain2) {
-  if (!domain2)
-    return "Waiting for domain to appear...";
-  return `Waiting for domain to become active (${domainStatusText(domain2)})...`;
-}
-async function addDomainAction({ log, runTask: runTask2, jsonMode }, hostname3, options) {
-  let domain2 = await runTask2(`Connecting ${hostname3}...`, async () => await addDomain(hostname3), { errorMessage: "Failed to connect domain" });
-  if (options.wait && !domain2.active) {
-    domain2 = await runTask2(waitMessage(domain2), async (updateMessage) => await waitForDomainActive(hostname3, {
-      onTick: (d2) => updateMessage(waitMessage(d2))
-    }), {
-      successMessage: `${hostname3} is active`,
-      errorMessage: "Domain did not become active"
-    });
-  }
-  if (jsonMode) {
-    return {
-      outroMessage: `Domain ${hostname3} is ${domainStatusText(domain2)}`,
-      stdout: toJsonStdout2(domain2)
-    };
-  }
-  logDomainSetup(domain2, log);
-  return {
-    outroMessage: domain2.active ? `${hostname3} is active` : `${hostname3} connected — add the CNAME record above to finish`
-  };
-}
-function getDomainsAddCommand() {
-  return new Base44Command("add").description("Connect a custom domain to this app").argument("<hostname>", "Domain to connect, e.g. app.example.com").option("--wait", "Poll until the domain and its TLS certificate are active").action(addDomainAction);
-}
-
-// src/cli/commands/domains/list.ts
-async function listDomainsAction({
-  log,
-  runTask: runTask2,
-  jsonMode
-}) {
-  const domains = await runTask2("Fetching domains...", async () => await listDomains(), { errorMessage: "Failed to fetch domains" });
-  if (jsonMode) {
-    return {
-      outroMessage: `${domains.length} domains`,
-      stdout: toJsonStdout2({ domains })
-    };
-  }
-  if (domains.length === 0) {
-    return { outroMessage: "No custom domains found" };
-  }
-  for (const domain2 of domains) {
-    log.message(formatDomainLine(domain2));
-  }
-  return {
-    outroMessage: `${domains.length} domain${domains.length !== 1 ? "s" : ""}`
-  };
-}
-function getDomainsListCommand() {
-  return new Base44Command("list").description("List custom domains connected to this app").action(listDomainsAction);
-}
-
-// src/cli/commands/domains/remove.ts
-async function removeDomainAction({ runTask: runTask2, jsonMode, isNonInteractive }, hostname3, options) {
-  if (isNonInteractive && !options.yes) {
-    throw new InvalidInputError("--yes is required in non-interactive mode");
-  }
-  if (!options.yes) {
-    const shouldRemove = await Re({
-      message: `Disconnect ${hostname3} from this app?`
-    });
-    if (Ct(shouldRemove) || !shouldRemove) {
-      return { outroMessage: "Removal cancelled" };
-    }
-  }
-  const result = await runTask2(`Removing ${hostname3}...`, async () => await removeDomain(hostname3), { errorMessage: "Failed to remove domain" });
-  return {
-    outroMessage: `Disconnected ${hostname3}`,
-    stdout: jsonMode ? toJsonStdout2(result) : undefined
-  };
-}
-function getDomainsRemoveCommand() {
-  return new Base44Command("remove").description("Disconnect a custom domain from this app").argument("<hostname>", "Domain to disconnect").option("-y, --yes", "Skip confirmation prompt").action(removeDomainAction);
-}
-
-// src/cli/commands/domains/index.ts
-function getDomainsCommand() {
-  return new Command("domains").description("Manage custom domains for full-stack apps").addCommand(getDomainsAddCommand()).addCommand(getDomainsListCommand()).addCommand(getDomainsRemoveCommand());
-}
-
 // src/cli/commands/entities/push.ts
 async function pushEntitiesAction({ isNonInteractive, log, runTask: runTask2 }, options) {
   const { entities } = await readProjectConfig();
@@ -258254,14 +258006,6 @@ function validateLimit(limit) {
 }
 async function logsAction(ctx, options) {
   validateLimit(options.limit);
-  if (options.follow) {
-    if (options.until) {
-      throw new InvalidInputError("--until cannot be combined with --follow (a stream has no end).");
-    }
-    if (options.order) {
-      throw new InvalidInputError("--order cannot be combined with --follow (a live tail always streams oldest to newest).");
-    }
-  }
   const specifiedFunctions = parseFunctionNames(options.function);
   const localProjectRoot = ctx.app?.projectRoot;
   const availableFunctionNames = localProjectRoot ? await getProjectFunctionNames(localProjectRoot) : await getRemoteFunctionNames();
@@ -258272,6 +258016,12 @@ async function logsAction(ctx, options) {
     };
   }
   if (options.follow) {
+    if (options.until) {
+      throw new InvalidInputError("--until cannot be combined with --follow (a stream has no end).");
+    }
+    if (options.order) {
+      throw new InvalidInputError("--order cannot be combined with --follow (a live tail always streams oldest to newest).");
+    }
     options.order = "asc";
     return followLogs(functionNames, options, availableFunctionNames, ctx.jsonMode);
   }
@@ -258476,7 +258226,7 @@ function withSandboxAuthHint(error48) {
     cause: error48
   });
 }
-async function callTool(appId, tool, payload, schema14, context, timeout2 = 60000) {
+async function callTool(appId, tool, payload, schema13, context, timeout2 = 60000) {
   const client = getSandboxClient(appId);
   let response;
   try {
@@ -258484,7 +258234,7 @@ async function callTool(appId, tool, payload, schema14, context, timeout2 = 6000
   } catch (error48) {
     throw withSandboxAuthHint(await ApiError.fromHttpError(error48, context));
   }
-  const result = schema14.safeParse(await response.json());
+  const result = schema13.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -258822,136 +258572,6 @@ function getSiteCommand() {
   return new Command("site").description("Manage app site (frontend app)").addCommand(getSiteDeployCommand()).addCommand(getSiteOpenCommand());
 }
 
-// src/core/slug/schema.ts
-var AppSlugResponseSchema = exports_external.object({ slug: exports_external.string().nullable().optional() }).transform((data) => ({ slug: data.slug ?? null }));
-var SlugSuggestionsSchema = exports_external.object({
-  suggestions: exports_external.array(exports_external.string())
-});
-
-// src/core/slug/api.ts
-async function getSlug() {
-  const { id } = getAppContext();
-  let response;
-  try {
-    response = await base44Client.get(`api/apps/${id}`);
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "fetching app slug");
-  }
-  const result = AppSlugResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-async function updateSlug(slug) {
-  const appClient = getAppClient();
-  const request = { slug };
-  let response;
-  try {
-    response = await appClient.patch("metadata/slug", { json: request });
-  } catch (error48) {
-    const apiError = await ApiError.fromHttpError(error48, "updating slug");
-    const suggestions = SlugSuggestionsSchema.safeParse(apiError.responseBody).data?.suggestions;
-    if (suggestions && suggestions.length > 0) {
-      apiError.hints.unshift({
-        message: `Available alternatives: ${suggestions.join(", ")}`
-      });
-    }
-    throw apiError;
-  }
-  const result = AppSlugResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
-// src/cli/commands/slug/shared.ts
-function toJsonStdout3(result) {
-  return `${JSON.stringify(result, null, 2)}
-`;
-}
-function logAppUrl(url2, log) {
-  log.message(`${theme.styles.header("URL")}: ${theme.colors.links(url2)}`);
-}
-
-// src/cli/commands/slug/reset.ts
-async function resetSlugAction({
-  log,
-  runTask: runTask2,
-  jsonMode
-}) {
-  const result = await runTask2("Resetting slug...", async () => {
-    const updated = await updateSlug(null);
-    return { slug: updated.slug, url: await getSiteUrl() };
-  }, { errorMessage: "Failed to reset slug" });
-  if (jsonMode) {
-    return {
-      outroMessage: `Slug reset to ${result.slug}`,
-      stdout: toJsonStdout3(result)
-    };
-  }
-  log.message(`${theme.styles.header("Slug")}: ${theme.styles.bold(result.slug ?? "")}`);
-  logAppUrl(result.url, log);
-  return { outroMessage: `Slug reset to ${result.slug}` };
-}
-function getSlugResetCommand() {
-  return new Base44Command("reset").description("Reset the slug to an auto-generated one").action(resetSlugAction);
-}
-
-// src/cli/commands/slug/set.ts
-async function setSlugAction({ log, runTask: runTask2, jsonMode }, slug) {
-  const result = await runTask2(`Setting slug to ${slug}...`, async () => {
-    const { slug: previousSlug } = await getSlug();
-    const updated = await updateSlug(slug);
-    return { previousSlug, slug: updated.slug, url: await getSiteUrl() };
-  }, { errorMessage: "Failed to update slug" });
-  if (jsonMode) {
-    return {
-      outroMessage: `Slug set to ${result.slug}`,
-      stdout: toJsonStdout3(result)
-    };
-  }
-  log.message(`${theme.styles.header("Slug")}: ${result.previousSlug ?? "(none)"} ${theme.styles.dim("→")} ${theme.styles.bold(result.slug ?? "")}`);
-  logAppUrl(result.url, log);
-  return { outroMessage: `Slug set to ${result.slug}` };
-}
-function getSlugSetCommand() {
-  return new Base44Command("set").description("Set a custom slug for this app").argument("<slug>", "New slug, e.g. my-app (3-50 chars: lowercase letters, numbers, hyphens)").action(setSlugAction);
-}
-
-// src/cli/commands/slug/show.ts
-async function showSlugAction({
-  log,
-  runTask: runTask2,
-  jsonMode
-}) {
-  const { slug, url: url2 } = await runTask2("Fetching slug...", async () => {
-    const { slug: slug2 } = await getSlug();
-    return { slug: slug2, url: slug2 ? await getSiteUrl() : null };
-  }, { errorMessage: "Failed to fetch slug" });
-  if (jsonMode) {
-    return {
-      outroMessage: slug ? `Slug: ${slug}` : "This app has no slug yet",
-      stdout: toJsonStdout3({ slug, url: url2 })
-    };
-  }
-  if (!slug) {
-    return {
-      outroMessage: "This app has no slug yet — set one with 'base44 slug set <slug>'"
-    };
-  }
-  log.message(`${theme.styles.header("Slug")}: ${theme.styles.bold(slug)}`);
-  if (url2) {
-    logAppUrl(url2, log);
-  }
-  return { outroMessage: `Slug: ${slug}` };
-}
-
-// src/cli/commands/slug/index.ts
-function getSlugCommand() {
-  return new Base44Command("slug").description("Show or change the app's URL slug (its public subdomain)").allowExcessArguments(false).action(showSlugAction).addCommand(getSlugSetCommand()).addCommand(getSlugResetCommand());
-}
-
 // src/core/types/generator.ts
 var import_common_tags = __toESM(require_lib2(), 1);
 var import_json_schema_to_typescript = __toESM(require_src3(), 1);
@@ -259008,9 +258628,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, source: _source, ...schema15 } = entity2;
+  const { name: name2, source: _source, ...schema13 } = entity2;
   const jsonSchema = {
-    ...schema15,
+    ...schema13,
     title: name2,
     additionalProperties: false
   };
@@ -260300,22 +259920,22 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema15 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema15) {
+    const schema13 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema13) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    return this.validator.validate(record2, schema15, partial2);
+    return this.validator.validate(record2, schema13, partial2);
   }
   prepareRecord(entityName, record2, partial2 = false) {
-    const schema15 = this.schemas.get(this.normalizeName(entityName));
-    if (!schema15) {
+    const schema13 = this.schemas.get(this.normalizeName(entityName));
+    if (!schema13) {
       throw new Error(`Entity "${entityName}" not found`);
     }
-    const filteredRecord = this.validator.filterFields(record2, schema15);
+    const filteredRecord = this.validator.filterFields(record2, schema13);
     if (partial2) {
       return filteredRecord;
     }
-    return this.validator.applyDefaults(filteredRecord, schema15);
+    return this.validator.applyDefaults(filteredRecord, schema13);
   }
   normalizeName(entityName) {
     return entityName.toLowerCase();
@@ -260609,13 +260229,13 @@ function checkRLS(rule, record2, user) {
     return false;
   return evaluateCondition(rule, record2, user);
 }
-function applyFLS(record2, schema15, user, operation) {
+function applyFLS(record2, schema13, user, operation) {
   if (Array.isArray(record2)) {
-    return record2.map((r5) => applyFLS(r5, schema15, user, operation));
+    return record2.map((r5) => applyFLS(r5, schema13, user, operation));
   }
   const result = {};
   for (const [key2, value] of Object.entries(record2)) {
-    const rule = schema15.properties[key2]?.rls?.[operation];
+    const rule = schema13.properties[key2]?.rls?.[operation];
     if (rule === undefined || checkRLS(rule, record2, user)) {
       result[key2] = value;
     }
@@ -260843,14 +260463,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Entity "${entityName}" not found` });
         return;
       }
-      const schema15 = db2.getSchema(entityName);
-      if (!schema15) {
+      const schema13 = db2.getSchema(entityName);
+      if (!schema13) {
         res.status(404).json({ error: `Schema for "${entityName}" not found` });
         return;
       }
       const currentUserResult = await resolveCurrentUser(db2, req);
       const currentUser = currentUserResult.ok ? currentUserResult.user : undefined;
-      await handler(req, res, collection, schema15, currentUser);
+      await handler(req, res, collection, schema13, currentUser);
     };
   }
   function emit(appId, entityName, type, data) {
@@ -260868,19 +260488,19 @@ async function createEntityRoutes(db2, logger2, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  function prepareCreateRecord(entityName, body, schema15, currentUser, now) {
+  function prepareCreateRecord(entityName, body, schema13, currentUser, now) {
     const { _id, ...recordBody } = body;
     const ownerFields = {
       created_by: currentUser?.email,
       created_by_id: currentUser?.id
     };
-    if (!checkRLS(schema15.rls?.create, {
+    if (!checkRLS(schema13.rls?.create, {
       ...recordBody,
       ...ownerFields
     }, currentUser)) {
       return;
     }
-    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema15, currentUser, "write");
+    const filteredBody = applyFLS(db2.prepareRecord(entityName, recordBody), schema13, currentUser, "write");
     db2.validate(entityName, filteredBody);
     return {
       ...filteredBody,
@@ -260892,7 +260512,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
   }
   const userRouter = createUserRouter(db2, logger2);
   router.use("/User", userRouter);
-  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.get("/:entityName/:id", withCollection(async (req, res, collection, schema13, currentUser) => {
     const { entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -260900,27 +260520,27 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema15.rls?.read, doc2, currentUser)) {
+      if (!checkRLS(schema13.rls?.read, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
         return;
       }
-      const result = applyFLS(stripInternalFields(doc2), schema15, currentUser, "read");
+      const result = applyFLS(stripInternalFields(doc2), schema13, currentUser, "read");
       res.json(result);
     } catch (error48) {
       logger2.error(`Error in GET /${entityName}/${id2}:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.get("/:entityName", withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.get("/:entityName", withCollection(async (req, res, collection, schema13, currentUser) => {
     const { entityName } = req.params;
     try {
       let results = stripInternalFields(await queryEntity(collection, req.query));
-      if (schema15.rls?.read !== undefined && schema15.rls.read !== true) {
-        results = results.filter((doc2) => checkRLS(schema15.rls.read, doc2, currentUser));
+      if (schema13.rls?.read !== undefined && schema13.rls.read !== true) {
+        results = results.filter((doc2) => checkRLS(schema13.rls.read, doc2, currentUser));
       }
-      results = results.map((doc2) => applyFLS(doc2, schema15, currentUser, "read"));
+      results = results.map((doc2) => applyFLS(doc2, schema13, currentUser, "read"));
       res.json(results);
     } catch (error48) {
       if (error48 instanceof InvalidInputError) {
@@ -260931,16 +260551,16 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       }
     }
   }));
-  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.post("/:entityName", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName } = req.params;
     try {
       const now = new Date().toISOString();
-      const record2 = prepareCreateRecord(entityName, req.body, schema15, currentUser, now);
+      const record2 = prepareCreateRecord(entityName, req.body, schema13, currentUser, now);
       if (!record2) {
         res.status(403).json({ error: "Permission denied" });
         return;
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema15, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(record2)), schema13, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -260952,7 +260572,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.post("/:entityName/bulk", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName } = req.params;
     if (!Array.isArray(req.body)) {
       res.status(400).json({ error: "Request body must be an array" });
@@ -260962,14 +260582,14 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       const now = new Date().toISOString();
       const records = [];
       for (const body of req.body) {
-        const record2 = prepareCreateRecord(entityName, body, schema15, currentUser, now);
+        const record2 = prepareCreateRecord(entityName, body, schema13, currentUser, now);
         if (!record2) {
           res.status(403).json({ error: "Permission denied" });
           return;
         }
         records.push(record2);
       }
-      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema15, currentUser, "read");
+      const inserted = applyFLS(stripInternalFields(await collection.insertAsync(records)), schema13, currentUser, "read");
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
@@ -260981,24 +260601,24 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.put("/:entityName/:id", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
-      if (schema15.rls?.update !== undefined) {
+      if (schema13.rls?.update !== undefined) {
         const existing = await collection.findOneAsync({ id: id2 });
         if (!existing) {
           res.status(404).json({ error: `Record with id "${id2}" not found` });
           return;
         }
-        if (!checkRLS(schema15.rls.update, existing, currentUser)) {
+        if (!checkRLS(schema13.rls.update, existing, currentUser)) {
           res.status(404).json({
             message: `Entity ${entityName} with ID ${id2} not found`
           });
           return;
         }
       }
-      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema15, currentUser, "write");
+      const filteredBody = applyFLS(db2.prepareRecord(entityName, body, true), schema13, currentUser, "write");
       db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
@@ -261009,7 +260629,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema15, currentUser, "read");
+      const updated = applyFLS(stripInternalFields(result.affectedDocuments), schema13, currentUser, "read");
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
@@ -261021,7 +260641,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.delete("/:entityName/:id", withCollection(async (req, res, collection, schema13, currentUser) => {
     const { appId, entityName, id: id2 } = req.params;
     try {
       const doc2 = await collection.findOneAsync({ id: id2 });
@@ -261029,7 +260649,7 @@ async function createEntityRoutes(db2, logger2, broadcast) {
         res.status(404).json({ error: `Record with id "${id2}" not found` });
         return;
       }
-      if (!checkRLS(schema15.rls?.delete, doc2, currentUser)) {
+      if (!checkRLS(schema13.rls?.delete, doc2, currentUser)) {
         res.status(404).json({
           message: `Entity ${entityName} with ID ${id2} not found`
         });
@@ -261043,11 +260663,11 @@ async function createEntityRoutes(db2, logger2, broadcast) {
       res.status(500).json({ error: "Internal server error" });
     }
   }));
-  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema15, currentUser) => {
+  router.delete("/:entityName", parseBody, withCollection(async (req, res, collection, schema13, currentUser) => {
     const { entityName } = req.params;
     try {
       const query = req.body || {};
-      const rlsDelete = schema15?.rls?.delete;
+      const rlsDelete = schema13?.rls?.delete;
       if (rlsDelete !== undefined && rlsDelete !== true) {
         if (rlsDelete === false && currentUser?.is_service !== true) {
           res.status(403).json({ error: "Permission denied" });
@@ -263464,8 +263084,6 @@ function createProgram(context) {
   program2.addCommand(getAgentSkillsCommand());
   program2.addCommand(getConnectorsCommand());
   program2.addCommand(getFunctionsCommand());
-  program2.addCommand(getDomainsCommand());
-  program2.addCommand(getSlugCommand());
   program2.addCommand(getSecretsCommand());
   program2.addCommand(getSandboxCommand());
   program2.addCommand(getAuthCommand());
@@ -267721,4 +267339,4 @@ export {
   CLIExitError
 };
 
-//# debugId=8FD9B142584B37FC64756E2164756E21
+//# debugId=F8606390894E3DA564756E2164756E21