@base44-preview/cli 0.0.34-pr.323.8ed63ab → 0.0.35-pr.321.30f0799

package/dist/cli/index.js

@@ -12578,7 +12578,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
   var which = require_which();
   var getPathKey = require_path_key();
   function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env2 = parsed.options.env || process.env;
+    const env3 = parsed.options.env || process.env;
     const cwd = process.cwd();
     const hasCustomCwd = parsed.options.cwd != null;
     const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
@@ -12590,7 +12590,7 @@ var require_resolveCommand = __commonJS((exports, module) => {
     let resolved;
     try {
       resolved = which.sync(parsed.command, {
-        path: env2[getPathKey({ env: env2 })],
+        path: env3[getPathKey({ env: env3 })],
         pathExt: withoutPathExt ? path11.delimiter : undefined
       });
     } catch (e2) {} finally {
@@ -108409,11 +108409,11 @@ function chooseDescription(descriptions, printWidth) {
   return firstWidth > printWidth && firstWidth > secondWidth ? secondDescription : firstDescription;
 }
 function createSchema(SchemaConstructor, parameters) {
-  const schema8 = new SchemaConstructor(parameters);
-  const subSchema = Object.create(schema8);
+  const schema9 = new SchemaConstructor(parameters);
+  const subSchema = Object.create(schema9);
   for (const handlerKey of HANDLER_KEYS) {
     if (handlerKey in parameters) {
-      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema8, Schema.prototype[handlerKey].length);
+      subSchema[handlerKey] = normalizeHandler(parameters[handlerKey], schema9, Schema.prototype[handlerKey].length);
     }
   }
   return subSchema;
@@ -109727,7 +109727,7 @@ function parse42(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
   }
   return res;
 }
-async function readFile2(file2) {
+async function readFile3(file2) {
   if (isUrlString(file2)) {
     file2 = new URL(file2);
   }
@@ -111753,9 +111753,9 @@ function optionInfoToSchema(optionInfo, {
       throw new Error(`Unexpected type ${optionInfo.type}`);
   }
   if (optionInfo.exception) {
-    parameters.validate = (value, schema8, utils3) => optionInfo.exception(value) || schema8.validate(value, utils3);
+    parameters.validate = (value, schema9, utils3) => optionInfo.exception(value) || schema9.validate(value, utils3);
   } else {
-    parameters.validate = (value, schema8, utils3) => value === undefined || schema8.validate(value, utils3);
+    parameters.validate = (value, schema9, utils3) => value === undefined || schema9.validate(value, utils3);
   }
   if (optionInfo.redirect) {
     handlers.redirect = (value) => !value ? undefined : {
@@ -111770,7 +111770,7 @@ function optionInfoToSchema(optionInfo, {
   }
   if (isCLI && !optionInfo.array) {
     const originalPreprocess = parameters.preprocess || ((x10) => x10);
-    parameters.preprocess = (value, schema8, utils3) => schema8.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
+    parameters.preprocess = (value, schema9, utils3) => schema9.preprocess(originalPreprocess(Array.isArray(value) ? method_at_default2(0, value, -1) : value), utils3);
   }
   return optionInfo.array ? ArraySchema.create({
     ...isCLI ? {
@@ -113347,9 +113347,9 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     };
     applyNormalization();
     for (const key2 of Object.keys(this._utils.schemas)) {
-      const schema8 = this._utils.schemas[key2];
+      const schema9 = this._utils.schemas[key2];
       if (!(key2 in newOptions)) {
-        const defaultResult = normalizeDefaultResult(schema8.default(this._utils));
+        const defaultResult = normalizeDefaultResult(schema9.default(this._utils));
         if ("value" in defaultResult) {
           restOptionsArray.push({ [key2]: defaultResult.value });
         }
@@ -113360,13 +113360,13 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
       if (!(key2 in newOptions)) {
         continue;
       }
-      const schema8 = this._utils.schemas[key2];
+      const schema9 = this._utils.schemas[key2];
       const value = newOptions[key2];
-      const newValue = schema8.postprocess(value, this._utils);
+      const newValue = schema9.postprocess(value, this._utils);
       if (newValue === VALUE_UNCHANGED) {
         continue;
       }
-      this._applyValidation(newValue, key2, schema8);
+      this._applyValidation(newValue, key2, schema9);
       newOptions[key2] = newValue;
     }
     this._applyPostprocess(newOptions);
@@ -113377,14 +113377,14 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     const transferredOptionsArray = [];
     const { knownKeys, unknownKeys } = this._partitionOptionKeys(options8);
     for (const key2 of knownKeys) {
-      const schema8 = this._utils.schemas[key2];
-      const value = schema8.preprocess(options8[key2], this._utils);
-      this._applyValidation(value, key2, schema8);
+      const schema9 = this._utils.schemas[key2];
+      const value = schema9.preprocess(options8[key2], this._utils);
+      this._applyValidation(value, key2, schema9);
       const appendTransferredOptions = ({ from, to: to5 }) => {
         transferredOptionsArray.push(typeof to5 === "string" ? { [to5]: from } : { [to5.key]: to5.value });
       };
       const warnDeprecated = ({ value: currentValue, redirectTo }) => {
-        const deprecatedResult = normalizeDeprecatedResult(schema8.deprecated(currentValue, this._utils), value, true);
+        const deprecatedResult = normalizeDeprecatedResult(schema9.deprecated(currentValue, this._utils), value, true);
         if (deprecatedResult === false) {
           return;
         }
@@ -113402,13 +113402,13 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
           }
         }
       };
-      const forwardResult = normalizeForwardResult(schema8.forward(value, this._utils), value);
+      const forwardResult = normalizeForwardResult(schema9.forward(value, this._utils), value);
       forwardResult.forEach(appendTransferredOptions);
-      const redirectResult = normalizeRedirectResult(schema8.redirect(value, this._utils), value);
+      const redirectResult = normalizeRedirectResult(schema9.redirect(value, this._utils), value);
       redirectResult.redirect.forEach(appendTransferredOptions);
       if ("remain" in redirectResult) {
         const remainingValue = redirectResult.remain;
-        newOptions[key2] = key2 in newOptions ? schema8.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
+        newOptions[key2] = key2 in newOptions ? schema9.overlap(newOptions[key2], remainingValue, this._utils) : remainingValue;
         warnDeprecated({ value: remainingValue });
       }
       for (const { from, to: to5 } of redirectResult.redirect) {
@@ -113436,8 +113436,8 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
     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, schema8) {
-    const validateResult = normalizeValidateResult(schema8.validate(value, this._utils), value);
+  _applyValidation(value, key2, schema9) {
+    const validateResult = normalizeValidateResult(schema9.validate(value, this._utils), value);
     if (validateResult !== true) {
       throw this._invalidHandler(key2, validateResult.value, this._utils);
     }
@@ -113479,8 +113479,8 @@ var require2, __filename2, __dirname4, __create2, __defProp3, __getOwnPropDesc,
       for (const key2 of unknownKeys) {
         const value = postprocessed.override[key2];
         this._applyUnknownHandler(key2, value, options8, (knownResultKey, knownResultValue) => {
-          const schema8 = this._utils.schemas[knownResultKey];
-          this._applyValidation(knownResultValue, knownResultKey, schema8);
+          const schema9 = this._utils.schemas[knownResultKey];
+          this._applyValidation(knownResultValue, knownResultKey, schema9);
           options8[knownResultKey] = knownResultValue;
         });
       }
@@ -118988,8 +118988,8 @@ var init_prettier = __esm(() => {
     "node_modules/picocolors/picocolors.js"(exports, module) {
       var p4 = process || {};
       var argv = p4.argv || [];
-      var env2 = p4.env || {};
-      var isColorSupported2 = !(!!env2.NO_COLOR || argv.includes("--no-color")) && (!!env2.FORCE_COLOR || argv.includes("--color") || p4.platform === "win32" || (p4.stdout || {}).isTTY && env2.TERM !== "dumb" || !!env2.CI);
+      var env3 = p4.env || {};
+      var isColorSupported2 = !(!!env3.NO_COLOR || argv.includes("--no-color")) && (!!env3.FORCE_COLOR || argv.includes("--color") || p4.platform === "win32" || (p4.stdout || {}).isTTY && env3.TERM !== "dumb" || !!env3.CI);
       var formatter = (open2, close, replace3 = open2) => (input) => {
         let string4 = "" + input, index = string4.indexOf(close, open2.length);
         return ~index ? open2 + replaceClose(string4, close, replace3, index) + close : open2 + string4 + close;
@@ -123521,7 +123521,7 @@ ${codeblock}`, options8);
     "\\": "\\"
   };
   KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-  read_file_default = readFile2;
+  read_file_default = readFile3;
   loadConfigFromPackageJson = process.versions.bun ? async function loadConfigFromBunPackageJson(file2) {
     const { prettier } = await readBunPackageJson(file2);
     return prettier;
@@ -127193,23 +127193,23 @@ var require_JSONSchema = __commonJS((exports) => {
   exports.Parent = Symbol("Parent");
   exports.Types = Symbol("Types");
   exports.Intersection = Symbol("Intersection");
-  exports.getRootSchema = (0, lodash_1.memoize)((schema8) => {
-    const parent = schema8[exports.Parent];
+  exports.getRootSchema = (0, lodash_1.memoize)((schema9) => {
+    const parent = schema9[exports.Parent];
     if (!parent) {
-      return schema8;
+      return schema9;
     }
     return (0, exports.getRootSchema)(parent);
   });
-  function isBoolean(schema8) {
-    return schema8 === true || schema8 === false;
+  function isBoolean(schema9) {
+    return schema9 === true || schema9 === false;
   }
   exports.isBoolean = isBoolean;
-  function isPrimitive(schema8) {
-    return !(0, lodash_1.isPlainObject)(schema8);
+  function isPrimitive(schema9) {
+    return !(0, lodash_1.isPlainObject)(schema9);
   }
   exports.isPrimitive = isPrimitive;
-  function isCompound(schema8) {
-    return Array.isArray(schema8.type) || "anyOf" in schema8 || "oneOf" in schema8;
+  function isCompound(schema9) {
+    return Array.isArray(schema9.type) || "anyOf" in schema9 || "oneOf" in schema9;
   }
   exports.isCompound = isCompound;
 });
@@ -127436,9 +127436,9 @@ var require_type2 = __commonJS((exports, module) => {
 var require_schema2 = __commonJS((exports, module) => {
   var YAMLException = require_exception2();
   var Type = require_type2();
-  function compileList(schema8, name2) {
+  function compileList(schema9, name2) {
     var result = [];
-    schema8[name2].forEach(function(currentType) {
+    schema9[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) {
@@ -129383,7 +129383,7 @@ var require_dumper2 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema8, map2) {
+  function compileStyleMap(schema9, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -129395,7 +129395,7 @@ var require_dumper2 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema8.compiledTypeMap["fallback"][tag];
+      type = schema9.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -130054,11 +130054,11 @@ var require_utils7 = __commonJS((exports) => {
   function traverseArray(arr, callback, processed) {
     arr.forEach((s5, k9) => traverse(s5, callback, processed, k9.toString()));
   }
-  function traverseIntersection(schema8, callback, processed) {
-    if (typeof schema8 !== "object" || !schema8) {
+  function traverseIntersection(schema9, callback, processed) {
+    if (typeof schema9 !== "object" || !schema9) {
       return;
     }
-    const r5 = schema8;
+    const r5 = schema9;
     const intersection2 = r5[JSONSchema_1.Intersection];
     if (!intersection2) {
       return;
@@ -130067,60 +130067,60 @@ var require_utils7 = __commonJS((exports) => {
       traverseArray(intersection2.allOf, callback, processed);
     }
   }
-  function traverse(schema8, callback, processed = new Set, key2) {
-    if (processed.has(schema8)) {
+  function traverse(schema9, callback, processed = new Set, key2) {
+    if (processed.has(schema9)) {
       return;
     }
-    processed.add(schema8);
-    callback(schema8, key2 !== null && key2 !== undefined ? key2 : null);
-    if (schema8.anyOf) {
-      traverseArray(schema8.anyOf, callback, processed);
+    processed.add(schema9);
+    callback(schema9, key2 !== null && key2 !== undefined ? key2 : null);
+    if (schema9.anyOf) {
+      traverseArray(schema9.anyOf, callback, processed);
     }
-    if (schema8.allOf) {
-      traverseArray(schema8.allOf, callback, processed);
+    if (schema9.allOf) {
+      traverseArray(schema9.allOf, callback, processed);
     }
-    if (schema8.oneOf) {
-      traverseArray(schema8.oneOf, callback, processed);
+    if (schema9.oneOf) {
+      traverseArray(schema9.oneOf, callback, processed);
     }
-    if (schema8.properties) {
-      traverseObjectKeys(schema8.properties, callback, processed);
+    if (schema9.properties) {
+      traverseObjectKeys(schema9.properties, callback, processed);
     }
-    if (schema8.patternProperties) {
-      traverseObjectKeys(schema8.patternProperties, callback, processed);
+    if (schema9.patternProperties) {
+      traverseObjectKeys(schema9.patternProperties, callback, processed);
     }
-    if (schema8.additionalProperties && typeof schema8.additionalProperties === "object") {
-      traverse(schema8.additionalProperties, callback, processed);
+    if (schema9.additionalProperties && typeof schema9.additionalProperties === "object") {
+      traverse(schema9.additionalProperties, callback, processed);
     }
-    if (schema8.items) {
-      const { items } = schema8;
+    if (schema9.items) {
+      const { items } = schema9;
       if (Array.isArray(items)) {
         traverseArray(items, callback, processed);
       } else {
         traverse(items, callback, processed);
       }
     }
-    if (schema8.additionalItems && typeof schema8.additionalItems === "object") {
-      traverse(schema8.additionalItems, callback, processed);
+    if (schema9.additionalItems && typeof schema9.additionalItems === "object") {
+      traverse(schema9.additionalItems, callback, processed);
     }
-    if (schema8.dependencies) {
-      if (Array.isArray(schema8.dependencies)) {
-        traverseArray(schema8.dependencies, callback, processed);
+    if (schema9.dependencies) {
+      if (Array.isArray(schema9.dependencies)) {
+        traverseArray(schema9.dependencies, callback, processed);
       } else {
-        traverseObjectKeys(schema8.dependencies, callback, processed);
+        traverseObjectKeys(schema9.dependencies, callback, processed);
       }
     }
-    if (schema8.definitions) {
-      traverseObjectKeys(schema8.definitions, callback, processed);
+    if (schema9.definitions) {
+      traverseObjectKeys(schema9.definitions, callback, processed);
     }
-    if (schema8.$defs) {
-      traverseObjectKeys(schema8.$defs, callback, processed);
+    if (schema9.$defs) {
+      traverseObjectKeys(schema9.$defs, callback, processed);
     }
-    if (schema8.not) {
-      traverse(schema8.not, callback, processed);
+    if (schema9.not) {
+      traverse(schema9.not, callback, processed);
     }
-    traverseIntersection(schema8, callback, processed);
-    Object.keys(schema8).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
-      const child = schema8[key3];
+    traverseIntersection(schema9, callback, processed);
+    Object.keys(schema9).filter((key3) => !BLACKLISTED_KEYS.has(key3)).forEach((key3) => {
+      const child = schema9[key3];
       if (child && typeof child === "object") {
         traverseObjectKeys(child, callback, processed);
       }
@@ -130202,14 +130202,14 @@ var require_utils7 = __commonJS((exports) => {
         return (_g2 = color()) === null || _g2 === undefined ? undefined : _g2.whiteBright.bgYellow;
     }
   }
-  function escapeBlockComment(schema8) {
+  function escapeBlockComment(schema9) {
     const replacer = "* /";
-    if (schema8 === null || typeof schema8 !== "object") {
+    if (schema9 === null || typeof schema9 !== "object") {
       return;
     }
-    for (const key2 of Object.keys(schema8)) {
-      if (key2 === "description" && typeof schema8[key2] === "string") {
-        schema8[key2] = schema8[key2].replace(/\*\//g, replacer);
+    for (const key2 of Object.keys(schema9)) {
+      if (key2 === "description" && typeof schema9[key2] === "string") {
+        schema9[key2] = schema9[key2].replace(/\*\//g, replacer);
       }
     }
   }
@@ -130221,45 +130221,45 @@ var require_utils7 = __commonJS((exports) => {
     return path_1.posix.join(path_1.posix.normalize(outputPath), ...filePathRel);
   }
   exports.pathTransform = pathTransform;
-  function maybeStripDefault(schema8) {
-    if (!("default" in schema8)) {
-      return schema8;
+  function maybeStripDefault(schema9) {
+    if (!("default" in schema9)) {
+      return schema9;
     }
-    switch (schema8.type) {
+    switch (schema9.type) {
       case "array":
-        if (Array.isArray(schema8.default)) {
-          return schema8;
+        if (Array.isArray(schema9.default)) {
+          return schema9;
         }
         break;
       case "boolean":
-        if (typeof schema8.default === "boolean") {
-          return schema8;
+        if (typeof schema9.default === "boolean") {
+          return schema9;
         }
         break;
       case "integer":
       case "number":
-        if (typeof schema8.default === "number") {
-          return schema8;
+        if (typeof schema9.default === "number") {
+          return schema9;
         }
         break;
       case "string":
-        if (typeof schema8.default === "string") {
-          return schema8;
+        if (typeof schema9.default === "string") {
+          return schema9;
         }
         break;
       case "null":
-        if (schema8.default === null) {
-          return schema8;
+        if (schema9.default === null) {
+          return schema9;
         }
         break;
       case "object":
-        if ((0, lodash_1.isPlainObject)(schema8.default)) {
-          return schema8;
+        if ((0, lodash_1.isPlainObject)(schema9.default)) {
+          return schema9;
         }
         break;
     }
-    delete schema8.default;
-    return schema8;
+    delete schema9.default;
+    return schema9;
   }
   exports.maybeStripDefault = maybeStripDefault;
   function appendToDescription(existingDescription, ...values) {
@@ -130273,11 +130273,11 @@ ${values.join(`
 `);
   }
   exports.appendToDescription = appendToDescription;
-  function isSchemaLike(schema8) {
-    if (!(0, lodash_1.isPlainObject)(schema8)) {
+  function isSchemaLike(schema9) {
+    if (!(0, lodash_1.isPlainObject)(schema9)) {
       return false;
     }
-    const parent = schema8[JSONSchema_1.Parent];
+    const parent = schema9[JSONSchema_1.Parent];
     if (parent === null) {
       return true;
     }
@@ -130294,7 +130294,7 @@ ${values.join(`
       "properties",
       "required"
     ];
-    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema8)) {
+    if (JSON_SCHEMA_KEYWORDS.some((_10) => parent[_10] === schema9)) {
       return false;
     }
     return true;
@@ -130592,13 +130592,13 @@ var require_typesOfSchema = __commonJS((exports) => {
   exports.typesOfSchema = undefined;
   var lodash_1 = require_lodash2();
   var JSONSchema_1 = require_JSONSchema();
-  function typesOfSchema(schema8) {
-    if (schema8.tsType) {
+  function typesOfSchema(schema9) {
+    if (schema9.tsType) {
       return new Set(["CUSTOM_TYPE"]);
     }
     const matchedTypes = new Set;
     for (const [schemaType, f7] of Object.entries(matchers)) {
-      if (f7(schema8)) {
+      if (f7(schema9)) {
         matchedTypes.add(schemaType);
       }
     }
@@ -130609,26 +130609,26 @@ var require_typesOfSchema = __commonJS((exports) => {
   }
   exports.typesOfSchema = typesOfSchema;
   var matchers = {
-    ALL_OF(schema8) {
-      return "allOf" in schema8;
+    ALL_OF(schema9) {
+      return "allOf" in schema9;
     },
-    ANY(schema8) {
-      if (Object.keys(schema8).length === 0) {
+    ANY(schema9) {
+      if (Object.keys(schema9).length === 0) {
         return true;
       }
-      return schema8.type === "any";
+      return schema9.type === "any";
     },
-    ANY_OF(schema8) {
-      return "anyOf" in schema8;
+    ANY_OF(schema9) {
+      return "anyOf" in schema9;
     },
-    BOOLEAN(schema8) {
-      if ("enum" in schema8) {
+    BOOLEAN(schema9) {
+      if ("enum" in schema9) {
         return false;
       }
-      if (schema8.type === "boolean") {
+      if (schema9.type === "boolean") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "boolean") {
+      if (!(0, JSONSchema_1.isCompound)(schema9) && typeof schema9.default === "boolean") {
         return true;
       }
       return false;
@@ -130636,74 +130636,74 @@ var require_typesOfSchema = __commonJS((exports) => {
     CUSTOM_TYPE() {
       return false;
     },
-    NAMED_ENUM(schema8) {
-      return "enum" in schema8 && "tsEnumNames" in schema8;
+    NAMED_ENUM(schema9) {
+      return "enum" in schema9 && "tsEnumNames" in schema9;
     },
-    NAMED_SCHEMA(schema8) {
-      return "$id" in schema8 && (("patternProperties" in schema8) || ("properties" in schema8));
+    NAMED_SCHEMA(schema9) {
+      return "$id" in schema9 && (("patternProperties" in schema9) || ("properties" in schema9));
     },
-    NEVER(schema8) {
-      return schema8 === false;
+    NEVER(schema9) {
+      return schema9 === false;
     },
-    NULL(schema8) {
-      return schema8.type === "null";
+    NULL(schema9) {
+      return schema9.type === "null";
     },
-    NUMBER(schema8) {
-      if ("enum" in schema8) {
+    NUMBER(schema9) {
+      if ("enum" in schema9) {
         return false;
       }
-      if (schema8.type === "integer" || schema8.type === "number") {
+      if (schema9.type === "integer" || schema9.type === "number") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "number") {
+      if (!(0, JSONSchema_1.isCompound)(schema9) && typeof schema9.default === "number") {
         return true;
       }
       return false;
     },
-    OBJECT(schema8) {
-      return schema8.type === "object" && !(0, lodash_1.isPlainObject)(schema8.additionalProperties) && !schema8.allOf && !schema8.anyOf && !schema8.oneOf && !schema8.patternProperties && !schema8.properties && !schema8.required;
+    OBJECT(schema9) {
+      return schema9.type === "object" && !(0, lodash_1.isPlainObject)(schema9.additionalProperties) && !schema9.allOf && !schema9.anyOf && !schema9.oneOf && !schema9.patternProperties && !schema9.properties && !schema9.required;
     },
-    ONE_OF(schema8) {
-      return "oneOf" in schema8;
+    ONE_OF(schema9) {
+      return "oneOf" in schema9;
     },
-    REFERENCE(schema8) {
-      return "$ref" in schema8;
+    REFERENCE(schema9) {
+      return "$ref" in schema9;
     },
-    STRING(schema8) {
-      if ("enum" in schema8) {
+    STRING(schema9) {
+      if ("enum" in schema9) {
         return false;
       }
-      if (schema8.type === "string") {
+      if (schema9.type === "string") {
         return true;
       }
-      if (!(0, JSONSchema_1.isCompound)(schema8) && typeof schema8.default === "string") {
+      if (!(0, JSONSchema_1.isCompound)(schema9) && typeof schema9.default === "string") {
         return true;
       }
       return false;
     },
-    TYPED_ARRAY(schema8) {
-      if (schema8.type && schema8.type !== "array") {
+    TYPED_ARRAY(schema9) {
+      if (schema9.type && schema9.type !== "array") {
         return false;
       }
-      return "items" in schema8;
+      return "items" in schema9;
     },
-    UNION(schema8) {
-      return Array.isArray(schema8.type);
+    UNION(schema9) {
+      return Array.isArray(schema9.type);
     },
-    UNNAMED_ENUM(schema8) {
-      if ("tsEnumNames" in schema8) {
+    UNNAMED_ENUM(schema9) {
+      if ("tsEnumNames" in schema9) {
         return false;
       }
-      if (schema8.type && schema8.type !== "boolean" && schema8.type !== "integer" && schema8.type !== "number" && schema8.type !== "string") {
+      if (schema9.type && schema9.type !== "boolean" && schema9.type !== "integer" && schema9.type !== "number" && schema9.type !== "string") {
         return false;
       }
-      return "enum" in schema8;
+      return "enum" in schema9;
     },
     UNNAMED_SCHEMA() {
       return false;
     },
-    UNTYPED_ARRAY(schema8) {
-      return schema8.type === "array" && !("items" in schema8);
+    UNTYPED_ARRAY(schema9) {
+      return schema9.type === "array" && !("items" in schema9);
     }
   };
 });
@@ -130714,10 +130714,10 @@ var require_applySchemaTyping = __commonJS((exports) => {
   exports.applySchemaTyping = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var typesOfSchema_1 = require_typesOfSchema();
-  function applySchemaTyping(schema8) {
+  function applySchemaTyping(schema9) {
     var _a7;
-    const types = (0, typesOfSchema_1.typesOfSchema)(schema8);
-    Object.defineProperty(schema8, JSONSchema_1.Types, {
+    const types = (0, typesOfSchema_1.typesOfSchema)(schema9);
+    Object.defineProperty(schema9, JSONSchema_1.Types, {
       enumerable: false,
       value: types,
       writable: false
@@ -130726,23 +130726,23 @@ var require_applySchemaTyping = __commonJS((exports) => {
       return;
     }
     const intersection2 = {
-      [JSONSchema_1.Parent]: schema8,
+      [JSONSchema_1.Parent]: schema9,
       [JSONSchema_1.Types]: new Set(["ALL_OF"]),
-      $id: schema8.$id,
-      description: schema8.description,
-      name: schema8.name,
-      title: schema8.title,
-      allOf: (_a7 = schema8.allOf) !== null && _a7 !== undefined ? _a7 : [],
+      $id: schema9.$id,
+      description: schema9.description,
+      name: schema9.name,
+      title: schema9.title,
+      allOf: (_a7 = schema9.allOf) !== null && _a7 !== undefined ? _a7 : [],
       required: [],
       additionalProperties: false
     };
     types.delete("ALL_OF");
-    delete schema8.allOf;
-    delete schema8.$id;
-    delete schema8.description;
-    delete schema8.name;
-    delete schema8.title;
-    Object.defineProperty(schema8, JSONSchema_1.Intersection, {
+    delete schema9.allOf;
+    delete schema9.$id;
+    delete schema9.description;
+    delete schema9.name;
+    delete schema9.title;
+    Object.defineProperty(schema9, JSONSchema_1.Intersection, {
       enumerable: false,
       value: intersection2,
       writable: false
@@ -130760,186 +130760,186 @@ var require_normalizer = __commonJS((exports) => {
   var applySchemaTyping_1 = require_applySchemaTyping();
   var util_1 = __require("util");
   var rules = new Map;
-  function hasType(schema8, type) {
-    return schema8.type === type || Array.isArray(schema8.type) && schema8.type.includes(type);
+  function hasType(schema9, type) {
+    return schema9.type === type || Array.isArray(schema9.type) && schema9.type.includes(type);
   }
-  function isObjectType(schema8) {
-    return schema8.properties !== undefined || hasType(schema8, "object") || hasType(schema8, "any");
+  function isObjectType(schema9) {
+    return schema9.properties !== undefined || hasType(schema9, "object") || hasType(schema9, "any");
   }
-  function isArrayType(schema8) {
-    return schema8.items !== undefined || hasType(schema8, "array") || hasType(schema8, "any");
+  function isArrayType(schema9) {
+    return schema9.items !== undefined || hasType(schema9, "array") || hasType(schema9, "any");
   }
-  function isEnumTypeWithoutTsEnumNames(schema8) {
-    return schema8.type === "string" && schema8.enum !== undefined && schema8.tsEnumNames === undefined;
+  function isEnumTypeWithoutTsEnumNames(schema9) {
+    return schema9.type === "string" && schema9.enum !== undefined && schema9.tsEnumNames === undefined;
   }
-  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema8) => {
-    if (Array.isArray(schema8.enum) && schema8.enum.some((e8) => e8 === null) && Array.isArray(schema8.type) && schema8.type.includes("null")) {
-      schema8.type = schema8.type.filter((type) => type !== "null");
+  rules.set('Remove `type=["null"]` if `enum=[null]`', (schema9) => {
+    if (Array.isArray(schema9.enum) && schema9.enum.some((e8) => e8 === null) && Array.isArray(schema9.type) && schema9.type.includes("null")) {
+      schema9.type = schema9.type.filter((type) => type !== "null");
     }
   });
-  rules.set("Destructure unary types", (schema8) => {
-    if (schema8.type && Array.isArray(schema8.type) && schema8.type.length === 1) {
-      schema8.type = schema8.type[0];
+  rules.set("Destructure unary types", (schema9) => {
+    if (schema9.type && Array.isArray(schema9.type) && schema9.type.length === 1) {
+      schema9.type = schema9.type[0];
     }
   });
-  rules.set("Add empty `required` property if none is defined", (schema8) => {
-    if (isObjectType(schema8) && !("required" in schema8)) {
-      schema8.required = [];
+  rules.set("Add empty `required` property if none is defined", (schema9) => {
+    if (isObjectType(schema9) && !("required" in schema9)) {
+      schema9.required = [];
     }
   });
-  rules.set("Transform `required`=false to `required`=[]", (schema8) => {
-    if (schema8.required === false) {
-      schema8.required = [];
+  rules.set("Transform `required`=false to `required`=[]", (schema9) => {
+    if (schema9.required === false) {
+      schema9.required = [];
     }
   });
-  rules.set("Default additionalProperties", (schema8, _10, options8) => {
-    if (isObjectType(schema8) && !("additionalProperties" in schema8) && schema8.patternProperties === undefined) {
-      schema8.additionalProperties = options8.additionalProperties;
+  rules.set("Default additionalProperties", (schema9, _10, options8) => {
+    if (isObjectType(schema9) && !("additionalProperties" in schema9) && schema9.patternProperties === undefined) {
+      schema9.additionalProperties = options8.additionalProperties;
     }
   });
-  rules.set("Transform id to $id", (schema8, fileName) => {
-    if (!(0, utils_1.isSchemaLike)(schema8)) {
+  rules.set("Transform id to $id", (schema9, fileName) => {
+    if (!(0, utils_1.isSchemaLike)(schema9)) {
       return;
     }
-    if (schema8.id && schema8.$id && schema8.id !== schema8.$id) {
-      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema8.id}, $id=${schema8.$id} in ${fileName}`);
+    if (schema9.id && schema9.$id && schema9.id !== schema9.$id) {
+      throw ReferenceError(`Schema must define either id or $id, not both. Given id=${schema9.id}, $id=${schema9.$id} in ${fileName}`);
     }
-    if (schema8.id) {
-      schema8.$id = schema8.id;
-      delete schema8.id;
+    if (schema9.id) {
+      schema9.$id = schema9.id;
+      delete schema9.id;
     }
   });
-  rules.set("Add an $id to anything that needs it", (schema8, fileName, _options, _key, dereferencedPaths) => {
-    if (!(0, utils_1.isSchemaLike)(schema8)) {
+  rules.set("Add an $id to anything that needs it", (schema9, fileName, _options, _key, dereferencedPaths) => {
+    if (!(0, utils_1.isSchemaLike)(schema9)) {
       return;
     }
-    if (!schema8.$id && !schema8[JSONSchema_1.Parent]) {
-      schema8.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
+    if (!schema9.$id && !schema9[JSONSchema_1.Parent]) {
+      schema9.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(fileName));
       return;
     }
-    if (!isArrayType(schema8) && !isObjectType(schema8)) {
+    if (!isArrayType(schema9) && !isObjectType(schema9)) {
       return;
     }
-    const dereferencedName = dereferencedPaths.get(schema8);
-    if (!schema8.$id && !schema8.title && dereferencedName) {
-      schema8.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
+    const dereferencedName = dereferencedPaths.get(schema9);
+    if (!schema9.$id && !schema9.title && dereferencedName) {
+      schema9.$id = (0, utils_1.toSafeString)((0, utils_1.justName)(dereferencedName));
     }
     if (dereferencedName) {
-      dereferencedPaths.delete(schema8);
+      dereferencedPaths.delete(schema9);
     }
   });
-  rules.set("Escape closing JSDoc comment", (schema8) => {
-    (0, utils_1.escapeBlockComment)(schema8);
+  rules.set("Escape closing JSDoc comment", (schema9) => {
+    (0, utils_1.escapeBlockComment)(schema9);
   });
-  rules.set("Add JSDoc comments for minItems and maxItems", (schema8) => {
-    if (!isArrayType(schema8)) {
+  rules.set("Add JSDoc comments for minItems and maxItems", (schema9) => {
+    if (!isArrayType(schema9)) {
       return;
     }
     const commentsToAppend = [
-      "minItems" in schema8 ? `@minItems ${schema8.minItems}` : "",
-      "maxItems" in schema8 ? `@maxItems ${schema8.maxItems}` : ""
+      "minItems" in schema9 ? `@minItems ${schema9.minItems}` : "",
+      "maxItems" in schema9 ? `@maxItems ${schema9.maxItems}` : ""
     ].filter(Boolean);
     if (commentsToAppend.length) {
-      schema8.description = (0, utils_1.appendToDescription)(schema8.description, ...commentsToAppend);
+      schema9.description = (0, utils_1.appendToDescription)(schema9.description, ...commentsToAppend);
     }
   });
-  rules.set("Optionally remove maxItems and minItems", (schema8, _fileName, options8) => {
-    if (!isArrayType(schema8)) {
+  rules.set("Optionally remove maxItems and minItems", (schema9, _fileName, options8) => {
+    if (!isArrayType(schema9)) {
       return;
     }
-    if ("minItems" in schema8 && options8.ignoreMinAndMaxItems) {
-      delete schema8.minItems;
+    if ("minItems" in schema9 && options8.ignoreMinAndMaxItems) {
+      delete schema9.minItems;
     }
-    if ("maxItems" in schema8 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
-      delete schema8.maxItems;
+    if ("maxItems" in schema9 && (options8.ignoreMinAndMaxItems || options8.maxItems === -1)) {
+      delete schema9.maxItems;
     }
   });
-  rules.set("Normalize schema.minItems", (schema8, _fileName, options8) => {
+  rules.set("Normalize schema.minItems", (schema9, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    if (!isArrayType(schema8)) {
+    if (!isArrayType(schema9)) {
       return;
     }
-    const { minItems } = schema8;
-    schema8.minItems = typeof minItems === "number" ? minItems : 0;
+    const { minItems } = schema9;
+    schema9.minItems = typeof minItems === "number" ? minItems : 0;
   });
-  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema8, _fileName, options8) => {
+  rules.set("Remove maxItems if it is big enough to likely cause OOMs", (schema9, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems || options8.maxItems === -1) {
       return;
     }
-    if (!isArrayType(schema8)) {
+    if (!isArrayType(schema9)) {
       return;
     }
-    const { maxItems, minItems } = schema8;
+    const { maxItems, minItems } = schema9;
     if (maxItems !== undefined && maxItems - minItems > options8.maxItems) {
-      delete schema8.maxItems;
+      delete schema9.maxItems;
     }
   });
-  rules.set("Normalize schema.items", (schema8, _fileName, options8) => {
+  rules.set("Normalize schema.items", (schema9, _fileName, options8) => {
     if (options8.ignoreMinAndMaxItems) {
       return;
     }
-    const { maxItems, minItems } = schema8;
+    const { maxItems, minItems } = schema9;
     const hasMaxItems = typeof maxItems === "number" && maxItems >= 0;
     const hasMinItems = typeof minItems === "number" && minItems > 0;
-    if (schema8.items && !Array.isArray(schema8.items) && (hasMaxItems || hasMinItems)) {
-      const items = schema8.items;
+    if (schema9.items && !Array.isArray(schema9.items) && (hasMaxItems || hasMinItems)) {
+      const items = schema9.items;
       const newItems = Array(maxItems || minItems || 0).fill(items);
       if (!hasMaxItems) {
-        schema8.additionalItems = items;
+        schema9.additionalItems = items;
       }
-      schema8.items = newItems;
+      schema9.items = newItems;
     }
-    if (Array.isArray(schema8.items) && hasMaxItems && maxItems < schema8.items.length) {
-      schema8.items = schema8.items.slice(0, maxItems);
+    if (Array.isArray(schema9.items) && hasMaxItems && maxItems < schema9.items.length) {
+      schema9.items = schema9.items.slice(0, maxItems);
     }
-    return schema8;
+    return schema9;
   });
-  rules.set("Remove extends, if it is empty", (schema8) => {
-    if (!schema8.hasOwnProperty("extends")) {
+  rules.set("Remove extends, if it is empty", (schema9) => {
+    if (!schema9.hasOwnProperty("extends")) {
       return;
     }
-    if (schema8.extends == null || Array.isArray(schema8.extends) && schema8.extends.length === 0) {
-      delete schema8.extends;
+    if (schema9.extends == null || Array.isArray(schema9.extends) && schema9.extends.length === 0) {
+      delete schema9.extends;
     }
   });
-  rules.set("Make extends always an array, if it is defined", (schema8) => {
-    if (schema8.extends == null) {
+  rules.set("Make extends always an array, if it is defined", (schema9) => {
+    if (schema9.extends == null) {
       return;
     }
-    if (!Array.isArray(schema8.extends)) {
-      schema8.extends = [schema8.extends];
+    if (!Array.isArray(schema9.extends)) {
+      schema9.extends = [schema9.extends];
     }
   });
-  rules.set("Transform definitions to $defs", (schema8, fileName) => {
-    if (schema8.definitions && schema8.$defs && !(0, util_1.isDeepStrictEqual)(schema8.definitions, schema8.$defs)) {
-      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema8.id} in ${fileName}`);
+  rules.set("Transform definitions to $defs", (schema9, fileName) => {
+    if (schema9.definitions && schema9.$defs && !(0, util_1.isDeepStrictEqual)(schema9.definitions, schema9.$defs)) {
+      throw ReferenceError(`Schema must define either definitions or $defs, not both. Given id=${schema9.id} in ${fileName}`);
     }
-    if (schema8.definitions) {
-      schema8.$defs = schema8.definitions;
-      delete schema8.definitions;
+    if (schema9.definitions) {
+      schema9.$defs = schema9.definitions;
+      delete schema9.definitions;
     }
   });
-  rules.set("Transform const to singleton enum", (schema8) => {
-    if (schema8.const !== undefined) {
-      schema8.enum = [schema8.const];
-      delete schema8.const;
+  rules.set("Transform const to singleton enum", (schema9) => {
+    if (schema9.const !== undefined) {
+      schema9.enum = [schema9.const];
+      delete schema9.const;
     }
   });
-  rules.set("Add tsEnumNames to enum types", (schema8, _10, options8) => {
+  rules.set("Add tsEnumNames to enum types", (schema9, _10, options8) => {
     var _a7;
-    if (isEnumTypeWithoutTsEnumNames(schema8) && options8.inferStringEnumKeysFromValues) {
-      schema8.tsEnumNames = (_a7 = schema8.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
+    if (isEnumTypeWithoutTsEnumNames(schema9) && options8.inferStringEnumKeysFromValues) {
+      schema9.tsEnumNames = (_a7 = schema9.enum) === null || _a7 === undefined ? undefined : _a7.map(String);
     }
   });
-  rules.set("Pre-calculate schema types and intersections", (schema8) => {
-    if (schema8 !== null && typeof schema8 === "object") {
-      (0, applySchemaTyping_1.applySchemaTyping)(schema8);
+  rules.set("Pre-calculate schema types and intersections", (schema9) => {
+    if (schema9 !== null && typeof schema9 === "object") {
+      (0, applySchemaTyping_1.applySchemaTyping)(schema9);
     }
   });
   function normalize(rootSchema, dereferencedPaths, filename, options8) {
-    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema8, key2) => rule(schema8, filename, options8, key2, dereferencedPaths)));
+    rules.forEach((rule) => (0, utils_1.traverse)(rootSchema, (schema9, key2) => rule(schema9, filename, options8, key2, dereferencedPaths)));
     return rootSchema;
   }
   exports.normalize = normalize;
@@ -131021,37 +131021,37 @@ var require_parser = __commonJS((exports) => {
   var AST_1 = require_AST();
   var JSONSchema_1 = require_JSONSchema();
   var utils_1 = require_utils7();
-  function parse10(schema8, options8, keyName, processed = new Map, usedNames = new Set) {
-    if ((0, JSONSchema_1.isPrimitive)(schema8)) {
-      if ((0, JSONSchema_1.isBoolean)(schema8)) {
-        return parseBooleanSchema(schema8, keyName, options8);
+  function parse10(schema9, options8, keyName, processed = new Map, usedNames = new Set) {
+    if ((0, JSONSchema_1.isPrimitive)(schema9)) {
+      if ((0, JSONSchema_1.isBoolean)(schema9)) {
+        return parseBooleanSchema(schema9, keyName, options8);
       }
-      return parseLiteral(schema8, keyName);
+      return parseLiteral(schema9, keyName);
     }
-    const intersection2 = schema8[JSONSchema_1.Intersection];
-    const types = schema8[JSONSchema_1.Types];
+    const intersection2 = schema9[JSONSchema_1.Intersection];
+    const types = schema9[JSONSchema_1.Types];
     if (intersection2) {
       const ast = parseAsTypeWithCache(intersection2, "ALL_OF", options8, keyName, processed, usedNames);
       types.forEach((type) => {
-        ast.params.push(parseAsTypeWithCache(schema8, type, options8, keyName, processed, usedNames));
+        ast.params.push(parseAsTypeWithCache(schema9, type, options8, keyName, processed, usedNames));
       });
-      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema8, "Output:", ast);
+      (0, utils_1.log)("blue", "parser", "Types:", [...types], "Input:", schema9, "Output:", ast);
       return ast;
     }
     if (types.size === 1) {
       const type = [...types][0];
-      const ast = parseAsTypeWithCache(schema8, type, options8, keyName, processed, usedNames);
-      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema8, "Output:", ast);
+      const ast = parseAsTypeWithCache(schema9, type, options8, keyName, processed, usedNames);
+      (0, utils_1.log)("blue", "parser", "Type:", type, "Input:", schema9, "Output:", ast);
       return ast;
     }
     throw new ReferenceError("Expected intersection schema. Please file an issue on GitHub.");
   }
   exports.parse = parse10;
-  function parseAsTypeWithCache(schema8, type, options8, keyName, processed = new Map, usedNames = new Set) {
-    let cachedTypeMap = processed.get(schema8);
+  function parseAsTypeWithCache(schema9, type, options8, keyName, processed = new Map, usedNames = new Set) {
+    let cachedTypeMap = processed.get(schema9);
     if (!cachedTypeMap) {
       cachedTypeMap = new Map;
-      processed.set(schema8, cachedTypeMap);
+      processed.set(schema9, cachedTypeMap);
     }
     const cachedAST = cachedTypeMap.get(type);
     if (cachedAST) {
@@ -131059,10 +131059,10 @@ var require_parser = __commonJS((exports) => {
     }
     const ast = {};
     cachedTypeMap.set(type, ast);
-    return Object.assign(ast, parseNonLiteral(schema8, type, options8, keyName, processed, usedNames));
+    return Object.assign(ast, parseNonLiteral(schema9, type, options8, keyName, processed, usedNames));
   }
-  function parseBooleanSchema(schema8, keyName, options8) {
-    if (schema8) {
+  function parseBooleanSchema(schema9, keyName, options8) {
+    if (schema9) {
       return {
         keyName,
         type: options8.unknownAny ? "UNKNOWN" : "ANY"
@@ -131073,157 +131073,157 @@ var require_parser = __commonJS((exports) => {
       type: "NEVER"
     };
   }
-  function parseLiteral(schema8, keyName) {
+  function parseLiteral(schema9, keyName) {
     return {
       keyName,
-      params: schema8,
+      params: schema9,
       type: "LITERAL"
     };
   }
-  function parseNonLiteral(schema8, type, options8, keyName, processed, usedNames) {
-    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema8));
-    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema8);
+  function parseNonLiteral(schema9, type, options8, keyName, processed, usedNames) {
+    const definitions = getDefinitionsMemoized((0, JSONSchema_1.getRootSchema)(schema9));
+    const keyNameFromDefinition = (0, lodash_1.findKey)(definitions, (_10) => _10 === schema9);
     switch (type) {
       case "ALL_OF":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.allOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.allOf.map((_10) => parse10(_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: schema8.description, deprecated: schema8.deprecated, keyName, standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8) });
+        return Object.assign(Object.assign({}, options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY), { comment: schema9.description, deprecated: schema9.deprecated, keyName, standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8) });
       case "ANY_OF":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.anyOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.anyOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "BOOLEAN":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "BOOLEAN"
         };
       case "CUSTOM_TYPE":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          params: schema8.tsType,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          params: schema9.tsType,
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "CUSTOM_TYPE"
         };
       case "NAMED_ENUM":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
-          params: schema8.enum.map((_10, n5) => ({
+          standaloneName: standaloneName(schema9, keyNameFromDefinition !== null && keyNameFromDefinition !== undefined ? keyNameFromDefinition : keyName, usedNames, options8),
+          params: schema9.enum.map((_10, n5) => ({
             ast: parseLiteral(_10, undefined),
-            keyName: schema8.tsEnumNames[n5]
+            keyName: schema9.tsEnumNames[n5]
           })),
           type: "ENUM"
         };
       case "NAMED_SCHEMA":
-        return newInterface(schema8, options8, processed, usedNames, keyName);
+        return newInterface(schema9, options8, processed, usedNames, keyName);
       case "NEVER":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "NEVER"
         };
       case "NULL":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "NULL"
         };
       case "NUMBER":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "NUMBER"
         };
       case "OBJECT":
         return {
-          comment: schema8.description,
+          comment: schema9.description,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "OBJECT",
-          deprecated: schema8.deprecated
+          deprecated: schema9.deprecated
         };
       case "ONE_OF":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.oneOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.oneOf.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
           type: "UNION"
         };
       case "REFERENCE":
-        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema8));
+        throw Error((0, util_1.format)("Refs should have been resolved by the resolver!", schema9));
       case "STRING":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "STRING"
         };
       case "TYPED_ARRAY":
-        if (Array.isArray(schema8.items)) {
-          const minItems2 = schema8.minItems;
-          const maxItems2 = schema8.maxItems;
+        if (Array.isArray(schema9.items)) {
+          const minItems2 = schema9.minItems;
+          const maxItems2 = schema9.maxItems;
           const arrayType = {
-            comment: schema8.description,
-            deprecated: schema8.deprecated,
+            comment: schema9.description,
+            deprecated: schema9.deprecated,
             keyName,
             maxItems: maxItems2,
             minItems: minItems2,
-            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-            params: schema8.items.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
+            standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+            params: schema9.items.map((_10) => parse10(_10, options8, undefined, processed, usedNames)),
             type: "TUPLE"
           };
-          if (schema8.additionalItems === true) {
+          if (schema9.additionalItems === true) {
             arrayType.spreadParam = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
-          } else if (schema8.additionalItems) {
-            arrayType.spreadParam = parse10(schema8.additionalItems, options8, undefined, processed, usedNames);
+          } else if (schema9.additionalItems) {
+            arrayType.spreadParam = parse10(schema9.additionalItems, options8, undefined, processed, usedNames);
           }
           return arrayType;
         } else {
           return {
-            comment: schema8.description,
-            deprecated: schema8.deprecated,
+            comment: schema9.description,
+            deprecated: schema9.deprecated,
             keyName,
-            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-            params: parse10(schema8.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
+            standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+            params: parse10(schema9.items, options8, `{keyNameFromDefinition}Items`, processed, usedNames),
             type: "ARRAY"
           };
         }
       case "UNION":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.type.map((type2) => {
-            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema8, "$id", "description", "title")), { type: type2 });
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.type.map((type2) => {
+            const member = Object.assign(Object.assign({}, (0, lodash_1.omit)(schema9, "$id", "description", "title")), { type: type2 });
             (0, utils_1.maybeStripDefault)(member);
             (0, applySchemaTyping_1.applySchemaTyping)(member);
             return parse10(member, options8, undefined, processed, usedNames);
@@ -131232,80 +131232,80 @@ var require_parser = __commonJS((exports) => {
         };
       case "UNNAMED_ENUM":
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
-          params: schema8.enum.map((_10) => parseLiteral(_10, undefined)),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
+          params: schema9.enum.map((_10) => parseLiteral(_10, undefined)),
           type: "UNION"
         };
       case "UNNAMED_SCHEMA":
-        return newInterface(schema8, options8, processed, usedNames, keyName, keyNameFromDefinition);
+        return newInterface(schema9, options8, processed, usedNames, keyName, keyNameFromDefinition);
       case "UNTYPED_ARRAY":
-        const minItems = schema8.minItems;
-        const maxItems = typeof schema8.maxItems === "number" ? schema8.maxItems : -1;
+        const minItems = schema9.minItems;
+        const maxItems = typeof schema9.maxItems === "number" ? schema9.maxItems : -1;
         const params = options8.unknownAny ? AST_1.T_UNKNOWN : AST_1.T_ANY;
         if (minItems > 0 || maxItems >= 0) {
           return {
-            comment: schema8.description,
-            deprecated: schema8.deprecated,
+            comment: schema9.description,
+            deprecated: schema9.deprecated,
             keyName,
-            maxItems: schema8.maxItems,
+            maxItems: schema9.maxItems,
             minItems,
             params: Array(Math.max(maxItems, minItems) || 0).fill(params),
             spreadParam: maxItems >= 0 ? undefined : params,
-            standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+            standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
             type: "TUPLE"
           };
         }
         return {
-          comment: schema8.description,
-          deprecated: schema8.deprecated,
+          comment: schema9.description,
+          deprecated: schema9.deprecated,
           keyName,
           params,
-          standaloneName: standaloneName(schema8, keyNameFromDefinition, usedNames, options8),
+          standaloneName: standaloneName(schema9, keyNameFromDefinition, usedNames, options8),
           type: "ARRAY"
         };
     }
   }
-  function standaloneName(schema8, keyNameFromDefinition, usedNames, options8) {
+  function standaloneName(schema9, keyNameFromDefinition, usedNames, options8) {
     var _a7;
-    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema8, keyNameFromDefinition)) || schema8.title || schema8.$id || keyNameFromDefinition;
+    const name2 = ((_a7 = options8.customName) === null || _a7 === undefined ? undefined : _a7.call(options8, schema9, keyNameFromDefinition)) || schema9.title || schema9.$id || keyNameFromDefinition;
     if (name2) {
       return (0, utils_1.generateName)(name2, usedNames);
     }
   }
-  function newInterface(schema8, options8, processed, usedNames, keyName, keyNameFromDefinition) {
-    const name2 = standaloneName(schema8, keyNameFromDefinition, usedNames, options8);
+  function newInterface(schema9, options8, processed, usedNames, keyName, keyNameFromDefinition) {
+    const name2 = standaloneName(schema9, keyNameFromDefinition, usedNames, options8);
     return {
-      comment: schema8.description,
-      deprecated: schema8.deprecated,
+      comment: schema9.description,
+      deprecated: schema9.deprecated,
       keyName,
-      params: parseSchema(schema8, options8, processed, usedNames, name2),
+      params: parseSchema(schema9, options8, processed, usedNames, name2),
       standaloneName: name2,
-      superTypes: parseSuperTypes(schema8, options8, processed, usedNames),
+      superTypes: parseSuperTypes(schema9, options8, processed, usedNames),
       type: "INTERFACE"
     };
   }
-  function parseSuperTypes(schema8, options8, processed, usedNames) {
-    const superTypes = schema8.extends;
+  function parseSuperTypes(schema9, options8, processed, usedNames) {
+    const superTypes = schema9.extends;
     if (!superTypes) {
       return [];
     }
     return superTypes.map((_10) => parse10(_10, options8, undefined, processed, usedNames));
   }
-  function parseSchema(schema8, options8, processed, usedNames, parentSchemaName) {
-    let asts = (0, lodash_1.map)(schema8.properties, (value, key2) => ({
+  function parseSchema(schema9, options8, processed, usedNames, parentSchemaName) {
+    let asts = (0, lodash_1.map)(schema9.properties, (value, key2) => ({
       ast: parse10(value, options8, key2, processed, usedNames),
       isPatternProperty: false,
-      isRequired: (0, lodash_1.includes)(schema8.required || [], key2),
+      isRequired: (0, lodash_1.includes)(schema9.required || [], key2),
       isUnreachableDefinition: false,
       keyName: key2
     }));
     let singlePatternProperty = false;
-    if (schema8.patternProperties) {
-      singlePatternProperty = !schema8.additionalProperties && Object.keys(schema8.patternProperties).length === 1;
-      asts = asts.concat((0, lodash_1.map)(schema8.patternProperties, (value, key2) => {
+    if (schema9.patternProperties) {
+      singlePatternProperty = !schema9.additionalProperties && Object.keys(schema9.patternProperties).length === 1;
+      asts = asts.concat((0, lodash_1.map)(schema9.patternProperties, (value, key2) => {
         const ast = parse10(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema definition
 via the \`patternProperty\` "${key2.replace("*/", "*\\/")}".`;
@@ -131315,14 +131315,14 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: !singlePatternProperty,
-          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema8.required || [], key2),
+          isRequired: singlePatternProperty || (0, lodash_1.includes)(schema9.required || [], key2),
           isUnreachableDefinition: false,
           keyName: singlePatternProperty ? "[k: string]" : key2
         };
       }));
     }
     if (options8.unreachableDefinitions) {
-      asts = asts.concat((0, lodash_1.map)(schema8.$defs, (value, key2) => {
+      asts = asts.concat((0, lodash_1.map)(schema9.$defs, (value, key2) => {
         const ast = parse10(value, options8, key2, processed, usedNames);
         const comment = `This interface was referenced by \`${parentSchemaName}\`'s JSON-Schema
 via the \`definition\` "${key2}".`;
@@ -131332,13 +131332,13 @@ ${comment}` : comment;
         return {
           ast,
           isPatternProperty: false,
-          isRequired: (0, lodash_1.includes)(schema8.required || [], key2),
+          isRequired: (0, lodash_1.includes)(schema9.required || [], key2),
           isUnreachableDefinition: true,
           keyName: key2
         };
       }));
     }
-    switch (schema8.additionalProperties) {
+    switch (schema9.additionalProperties) {
       case undefined:
       case true:
         if (singlePatternProperty) {
@@ -131355,7 +131355,7 @@ ${comment}` : comment;
         return asts;
       default:
         return asts.concat({
-          ast: parse10(schema8.additionalProperties, options8, "[k: string]", processed, usedNames),
+          ast: parse10(schema9.additionalProperties, options8, "[k: string]", processed, usedNames),
           isPatternProperty: false,
           isRequired: true,
           isUnreachableDefinition: false,
@@ -131363,22 +131363,22 @@ ${comment}` : comment;
         });
     }
   }
-  function getDefinitions(schema8, isSchema = true, processed = new Set) {
-    if (processed.has(schema8)) {
+  function getDefinitions(schema9, isSchema = true, processed = new Set) {
+    if (processed.has(schema9)) {
       return {};
     }
-    processed.add(schema8);
-    if (Array.isArray(schema8)) {
-      return schema8.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
+    processed.add(schema9);
+    if (Array.isArray(schema9)) {
+      return schema9.reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(cur, false, processed)), {});
     }
-    if ((0, lodash_1.isPlainObject)(schema8)) {
-      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema8) ? schema8.$defs : {}), Object.keys(schema8).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema8[cur], false, processed)), {}));
+    if ((0, lodash_1.isPlainObject)(schema9)) {
+      return Object.assign(Object.assign({}, isSchema && hasDefinitions(schema9) ? schema9.$defs : {}), Object.keys(schema9).reduce((prev, cur) => Object.assign(Object.assign({}, prev), getDefinitions(schema9[cur], false, processed)), {}));
     }
     return {};
   }
   var getDefinitionsMemoized = (0, lodash_1.memoize)(getDefinitions);
-  function hasDefinitions(schema8) {
-    return "$defs" in schema8;
+  function hasDefinitions(schema9) {
+    return "$defs" in schema9;
   }
 });
 
@@ -132756,7 +132756,7 @@ var require_parse6 = __commonJS((exports) => {
       extension: url3.getExtension(path18)
     };
     try {
-      const resolver = await readFile3(file2, options8, $refs);
+      const resolver = await readFile4(file2, options8, $refs);
       $ref.pathType = resolver.plugin.name;
       file2.data = resolver.result;
       const parser = await parseFile(file2, options8, $refs);
@@ -132769,7 +132769,7 @@ var require_parse6 = __commonJS((exports) => {
       throw err;
     }
   }
-  async function readFile3(file2, options8, $refs) {
+  async function readFile4(file2, options8, $refs) {
     let resolvers = plugins.all(options8.resolve);
     resolvers = plugins.filter(resolvers, "canRead", file2);
     plugins.sort(resolvers);
@@ -133083,9 +133083,9 @@ var require_type3 = __commonJS((exports, module) => {
 var require_schema3 = __commonJS((exports, module) => {
   var YAMLException = require_exception3();
   var Type = require_type3();
-  function compileList(schema8, name2) {
+  function compileList(schema9, name2) {
     var result = [];
-    schema8[name2].forEach(function(currentType) {
+    schema9[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) {
@@ -135030,7 +135030,7 @@ var require_dumper3 = __commonJS((exports, module) => {
     "OFF"
   ];
   var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema8, map2) {
+  function compileStyleMap(schema9, map2) {
     var result, keys, index, length, tag, style, type;
     if (map2 === null)
       return {};
@@ -135042,7 +135042,7 @@ var require_dumper3 = __commonJS((exports, module) => {
       if (tag.slice(0, 2) === "!!") {
         tag = "tag:yaml.org,2002:" + tag.slice(2);
       }
-      type = schema8.compiledTypeMap["fallback"][tag];
+      type = schema9.compiledTypeMap["fallback"][tag];
       if (type && _hasOwnProperty.call(type.styleAliases, style)) {
         style = type.styleAliases[style];
       }
@@ -135977,7 +135977,7 @@ var require_normalize_args = __commonJS((exports) => {
   var options_js_1 = require_options();
   function normalizeArgs(_args) {
     let path18;
-    let schema8;
+    let schema9;
     let options8;
     let callback;
     const args = Array.prototype.slice.call(_args);
@@ -135987,15 +135987,15 @@ var require_normalize_args = __commonJS((exports) => {
     if (typeof args[0] === "string") {
       path18 = args[0];
       if (typeof args[2] === "object") {
-        schema8 = args[1];
+        schema9 = args[1];
         options8 = args[2];
       } else {
-        schema8 = undefined;
+        schema9 = undefined;
         options8 = args[1];
       }
     } else {
       path18 = "";
-      schema8 = args[0];
+      schema9 = args[0];
       options8 = args[1];
     }
     try {
@@ -136003,12 +136003,12 @@ var require_normalize_args = __commonJS((exports) => {
     } catch (e8) {
       console.error(`JSON Schema Ref Parser: Error normalizing options: ${e8}`);
     }
-    if (!options8.mutateInputSchema && typeof schema8 === "object") {
-      schema8 = JSON.parse(JSON.stringify(schema8));
+    if (!options8.mutateInputSchema && typeof schema9 === "object") {
+      schema9 = JSON.parse(JSON.stringify(schema9));
     }
     return {
       path: path18,
-      schema: schema8,
+      schema: schema9,
       options: options8,
       callback
     };
@@ -136797,12 +136797,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* (schema8, { cwd, $refOptions }) {
-      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema8);
+    return __awaiter(this, arguments, undefined, function* (schema9, { cwd, $refOptions }) {
+      (0, utils_1.log)("green", "dereferencer", "Dereferencing input schema:", cwd, schema9);
       const parser = new json_schema_ref_parser_1.$RefParser;
       const dereferencedPaths = new WeakMap;
-      const dereferencedSchema = yield parser.dereference(cwd, schema8, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema9) {
-        dereferencedPaths.set(schema9, $ref);
+      const dereferencedSchema = yield parser.dereference(cwd, schema9, Object.assign(Object.assign({}, $refOptions), { dereference: Object.assign(Object.assign({}, $refOptions.dereference), { onDereference($ref, schema10) {
+        dereferencedPaths.set(schema10, $ref);
       } }) }));
       return { dereferencedPaths, dereferencedSchema };
     });
@@ -136816,46 +136816,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", (schema8) => {
-    if (schema8.enum && schema8.tsEnumNames && schema8.enum.length !== schema8.tsEnumNames.length) {
+  rules.set("Enum members and tsEnumNames must be of the same length", (schema9) => {
+    if (schema9.enum && schema9.tsEnumNames && schema9.enum.length !== schema9.tsEnumNames.length) {
       return false;
     }
   });
-  rules.set("tsEnumNames must be an array of strings", (schema8) => {
-    if (schema8.tsEnumNames && schema8.tsEnumNames.some((_10) => typeof _10 !== "string")) {
+  rules.set("tsEnumNames must be an array of strings", (schema9) => {
+    if (schema9.tsEnumNames && schema9.tsEnumNames.some((_10) => typeof _10 !== "string")) {
       return false;
     }
   });
-  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema8) => {
-    const { maxItems, minItems } = schema8;
+  rules.set("When both maxItems and minItems are present, maxItems >= minItems", (schema9) => {
+    const { maxItems, minItems } = schema9;
     if (typeof maxItems === "number" && typeof minItems === "number") {
       return maxItems >= minItems;
     }
   });
-  rules.set("When maxItems exists, maxItems >= 0", (schema8) => {
-    const { maxItems } = schema8;
+  rules.set("When maxItems exists, maxItems >= 0", (schema9) => {
+    const { maxItems } = schema9;
     if (typeof maxItems === "number") {
       return maxItems >= 0;
     }
   });
-  rules.set("When minItems exists, minItems >= 0", (schema8) => {
-    const { minItems } = schema8;
+  rules.set("When minItems exists, minItems >= 0", (schema9) => {
+    const { minItems } = schema9;
     if (typeof minItems === "number") {
       return minItems >= 0;
     }
   });
-  rules.set("deprecated must be a boolean", (schema8) => {
-    const typeOfDeprecated = typeof schema8.deprecated;
+  rules.set("deprecated must be a boolean", (schema9) => {
+    const typeOfDeprecated = typeof schema9.deprecated;
     return typeOfDeprecated === "boolean" || typeOfDeprecated === "undefined";
   });
-  function validate2(schema8, filename) {
+  function validate2(schema9, filename) {
     const errors4 = [];
     rules.forEach((rule, ruleName) => {
-      (0, utils_1.traverse)(schema8, (schema9, key2) => {
-        if (rule(schema9) === false) {
+      (0, utils_1.traverse)(schema9, (schema10, key2) => {
+        if (rule(schema10) === false) {
           errors4.push(`Error at key "${key2}" in file "${filename}": ${ruleName}`);
         }
-        return schema9;
+        return schema10;
       });
     });
     return errors4;
@@ -136869,25 +136869,25 @@ var require_linker = __commonJS((exports) => {
   exports.link = undefined;
   var JSONSchema_1 = require_JSONSchema();
   var lodash_1 = require_lodash2();
-  function link2(schema8, parent = null) {
-    if (!Array.isArray(schema8) && !(0, lodash_1.isPlainObject)(schema8)) {
-      return schema8;
+  function link2(schema9, parent = null) {
+    if (!Array.isArray(schema9) && !(0, lodash_1.isPlainObject)(schema9)) {
+      return schema9;
     }
-    if (schema8.hasOwnProperty(JSONSchema_1.Parent)) {
-      return schema8;
+    if (schema9.hasOwnProperty(JSONSchema_1.Parent)) {
+      return schema9;
     }
-    Object.defineProperty(schema8, JSONSchema_1.Parent, {
+    Object.defineProperty(schema9, JSONSchema_1.Parent, {
       enumerable: false,
       value: parent,
       writable: false
     });
-    if (Array.isArray(schema8)) {
-      schema8.forEach((child) => link2(child, schema8));
+    if (Array.isArray(schema9)) {
+      schema9.forEach((child) => link2(child, schema9));
     }
-    for (const key2 in schema8) {
-      link2(schema8[key2], schema8);
+    for (const key2 in schema9) {
+      link2(schema9[key2], schema9);
     }
-    return schema8;
+    return schema9;
   }
   exports.link = link2;
 });
@@ -136979,8 +136979,8 @@ var require_src3 = __commonJS((exports) => {
     unknownAny: true
   };
   function compileFromFile(filename, options8 = exports.DEFAULT_OPTIONS) {
-    const schema8 = parseAsJSONSchema(filename);
-    return compile(schema8, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
+    const schema9 = parseAsJSONSchema(filename);
+    return compile(schema9, (0, utils_1.stripExtension)(filename), Object.assign({ cwd: (0, path_1.dirname)(filename) }, options8));
   }
   exports.compileFromFile = compileFromFile;
   function parseAsJSONSchema(filename) {
@@ -136990,7 +136990,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* (schema8, name2, options8 = {}) {
+    return __awaiter(this, arguments, undefined, function* (schema9, name2, options8 = {}) {
       (0, optionValidator_1.validateOptions)(options8);
       const _options = (0, lodash_1.merge)({}, exports.DEFAULT_OPTIONS, options8);
       const start = Date.now();
@@ -137000,7 +137000,7 @@ var require_src3 = __commonJS((exports) => {
       if (!(0, lodash_1.endsWith)(_options.cwd, "/")) {
         _options.cwd += "/";
       }
-      const _schema = (0, lodash_1.cloneDeep)(schema8);
+      const _schema = (0, lodash_1.cloneDeep)(schema9);
       const { dereferencedPaths, dereferencedSchema } = yield (0, resolver_1.dereference)(_schema, _options);
       if (process.env.VERBOSE) {
         if ((0, util_1.isDeepStrictEqual)(_schema, dereferencedSchema)) {
@@ -137500,7 +137500,7 @@ var require_ms = __commonJS((exports, module) => {
 
 // node_modules/debug/src/common.js
 var require_common7 = __commonJS((exports, module) => {
-  function setup(env2) {
+  function setup(env3) {
     createDebug.debug = createDebug;
     createDebug.default = createDebug;
     createDebug.coerce = coerce;
@@ -137509,8 +137509,8 @@ var require_common7 = __commonJS((exports, module) => {
     createDebug.enabled = enabled;
     createDebug.humanize = require_ms();
     createDebug.destroy = destroy;
-    Object.keys(env2).forEach((key2) => {
-      createDebug[key2] = env2[key2];
+    Object.keys(env3).forEach((key2) => {
+      createDebug[key2] = env3[key2];
     });
     createDebug.names = [];
     createDebug.skips = [];
@@ -155558,7 +155558,7 @@ var require_finalhandler = __commonJS((exports, module) => {
   module.exports = finalhandler;
   function finalhandler(req, res, options8) {
     var opts = options8 || {};
-    var env2 = opts.env || "development";
+    var env3 = opts.env || "development";
     var onerror = opts.onerror;
     return function(err) {
       var headers;
@@ -155575,7 +155575,7 @@ var require_finalhandler = __commonJS((exports, module) => {
         } else {
           headers = getErrorHeaders(err);
         }
-        msg = getErrorMessage(err, status, env2);
+        msg = getErrorMessage(err, status, env3);
       } else {
         status = 404;
         msg = "Cannot " + req.method + " " + encodeUrl(getResourceName(req));
@@ -155600,9 +155600,9 @@ var require_finalhandler = __commonJS((exports, module) => {
     }
     return { ...err.headers };
   }
-  function getErrorMessage(err, status, env2) {
+  function getErrorMessage(err, status, env3) {
     var msg;
-    if (env2 !== "production") {
+    if (env3 !== "production") {
       msg = err.stack;
       if (!msg && typeof err.toString === "function") {
         msg = err.toString();
@@ -157928,10 +157928,10 @@ var require_application = __commonJS((exports, module) => {
     });
   };
   app.defaultConfiguration = function defaultConfiguration() {
-    var env2 = "development";
+    var env3 = "development";
     this.enable("x-powered-by");
     this.set("etag", "weak");
-    this.set("env", env2);
+    this.set("env", env3);
     this.set("query parser", "simple");
     this.set("subdomain offset", 2);
     this.set("trust proxy", false);
@@ -157939,7 +157939,7 @@ var require_application = __commonJS((exports, module) => {
       configurable: true,
       value: true
     });
-    debug("booting in %s mode", env2);
+    debug("booting in %s mode", env3);
     this.on("mount", function onmount(parent) {
       if (this.settings[trustProxyDefaultSymbol] === true && typeof parent.settings["trust proxy fn"] === "function") {
         delete this.settings["trust proxy"];
@@ -157956,7 +157956,7 @@ var require_application = __commonJS((exports, module) => {
     this.set("view", View);
     this.set("views", resolve5("views"));
     this.set("jsonp callback name", "callback");
-    if (env2 === "production") {
+    if (env3 === "production") {
       this.enable("view cache");
     }
   };
@@ -159228,19 +159228,19 @@ var require_content_disposition = __commonJS((exports, module) => {
 // node_modules/cookie-signature/index.js
 var require_cookie_signature = __commonJS((exports) => {
   var crypto = __require("crypto");
-  exports.sign = function(val, secret) {
+  exports.sign = function(val, secret2) {
     if (typeof val != "string")
       throw new TypeError("Cookie value must be provided as a string.");
-    if (secret == null)
+    if (secret2 == null)
       throw new TypeError("Secret key must be provided.");
-    return val + "." + crypto.createHmac("sha256", secret).update(val).digest("base64").replace(/\=+$/, "");
+    return val + "." + crypto.createHmac("sha256", secret2).update(val).digest("base64").replace(/\=+$/, "");
   };
-  exports.unsign = function(input, secret) {
+  exports.unsign = function(input, secret2) {
     if (typeof input != "string")
       throw new TypeError("Signed cookie string must be provided.");
-    if (secret == null)
+    if (secret2 == null)
       throw new TypeError("Secret key must be provided.");
-    var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports.sign(tentativeValue, secret), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);
+    var tentativeValue = input.slice(0, input.lastIndexOf(".")), expectedInput = exports.sign(tentativeValue, secret2), expectedBuffer = Buffer.from(expectedInput), inputBuffer = Buffer.from(input);
     return expectedBuffer.length === inputBuffer.length && crypto.timingSafeEqual(expectedBuffer, inputBuffer) ? tentativeValue : false;
   };
 });
@@ -160231,14 +160231,14 @@ var require_response = __commonJS((exports, module) => {
   };
   res.cookie = function(name2, value, options8) {
     var opts = { ...options8 };
-    var secret = this.req.secret;
+    var secret2 = this.req.secret;
     var signed = opts.signed;
-    if (signed && !secret) {
+    if (signed && !secret2) {
       throw new Error('cookieParser("secret") required for signed cookies');
     }
     var val = typeof value === "object" ? "j:" + JSON.stringify(value) : String(value);
     if (signed) {
-      val = "s:" + sign2(val, secret);
+      val = "s:" + sign2(val, secret2);
     }
     if (opts.maxAge != null) {
       var maxAge = opts.maxAge - 0;
@@ -162752,7 +162752,7 @@ var require_dist3 = __commonJS((exports, module) => {
     determineAgent: () => determineAgent
   });
   module.exports = __toCommonJS(src_exports);
-  var import_promises19 = __require("node:fs/promises");
+  var import_promises20 = __require("node:fs/promises");
   var import_node_fs18 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
@@ -162810,7 +162810,7 @@ var require_dist3 = __commonJS((exports, module) => {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises19.access)(DEVIN_LOCAL_PATH, import_node_fs18.constants.F_OK);
+      await (0, import_promises20.access)(DEVIN_LOCAL_PATH, import_node_fs18.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -186055,7 +186055,7 @@ var DeployFunctionsResponseSchema = exports_external.object({
 var LogLevelSchema = exports_external.enum(["info", "warning", "error", "debug"]);
 var FunctionLogEntrySchema = exports_external.object({
   time: exports_external.string(),
-  level: exports_external.string(),
+  level: LogLevelSchema,
   message: exports_external.string()
 });
 var FunctionLogsResponseSchema = exports_external.array(FunctionLogEntrySchema);
@@ -186673,6 +186673,85 @@ async function getUserInfo(accessToken) {
   }
   return result.data;
 }
+// src/core/resources/secret/schema.ts
+var ListSecretsResponseSchema = exports_external.record(exports_external.string(), exports_external.string());
+var SetSecretsResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+var DeleteSecretResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+
+// src/core/resources/secret/api.ts
+async function listSecrets() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("secrets");
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing secrets");
+  }
+  const result = ListSecretsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function setSecrets(secrets) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.post("secrets", {
+      json: secrets
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "setting secrets");
+  }
+  const result = SetSecretsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function deleteSecret(name2) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.delete("secrets", {
+      searchParams: { secret_name: name2 }
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "deleting secret");
+  }
+  const result = DeleteSecretResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+// src/core/resources/secret/env.ts
+import { readFile as readFile2 } from "node:fs/promises";
+async function parseEnvFile(filePath) {
+  const content = await readFile2(filePath, "utf-8");
+  const secrets = {};
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, eqIndex).trim();
+    const value = trimmed.slice(eqIndex + 1);
+    if (key) {
+      secrets[key] = value;
+    }
+  }
+  return secrets;
+}
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code2) => `\x1B[${code2 + offset}m`;
@@ -186860,7 +186939,7 @@ function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process5.
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
-var { env } = process5;
+var { env: env2 } = process5;
 var flagForceColor;
 if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
   flagForceColor = 0;
@@ -186868,14 +186947,14 @@ if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || has
   flagForceColor = 1;
 }
 function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
+  if ("FORCE_COLOR" in env2) {
+    if (env2.FORCE_COLOR === "true") {
       return 1;
     }
-    if (env.FORCE_COLOR === "false") {
+    if (env2.FORCE_COLOR === "false") {
       return 0;
     }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    return env2.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env2.FORCE_COLOR, 10), 3);
   }
 }
 function translateLevel(level) {
@@ -186906,14 +186985,14 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       return 2;
     }
   }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+  if ("TF_BUILD" in env2 && "AGENT_NAME" in env2) {
     return 1;
   }
   if (haveStream && !streamIsTTY && forceColor === undefined) {
     return 0;
   }
   const min = forceColor || 0;
-  if (env.TERM === "dumb") {
+  if (env2.TERM === "dumb") {
     return min;
   }
   if (process5.platform === "win32") {
@@ -186923,33 +187002,33 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     }
     return 1;
   }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+  if ("CI" in env2) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env2))) {
       return 3;
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
       return 1;
     }
     return min;
   }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  if ("TEAMCITY_VERSION" in env2) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
   }
-  if (env.COLORTERM === "truecolor") {
+  if (env2.COLORTERM === "truecolor") {
     return 3;
   }
-  if (env.TERM === "xterm-kitty") {
+  if (env2.TERM === "xterm-kitty") {
     return 3;
   }
-  if (env.TERM === "xterm-ghostty") {
+  if (env2.TERM === "xterm-ghostty") {
     return 3;
   }
-  if (env.TERM === "wezterm") {
+  if (env2.TERM === "wezterm") {
     return 3;
   }
-  if ("TERM_PROGRAM" in env) {
-    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
+  if ("TERM_PROGRAM" in env2) {
+    const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env2.TERM_PROGRAM) {
       case "iTerm.app": {
         return version2 >= 3 ? 3 : 2;
       }
@@ -186958,13 +187037,13 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       }
     }
   }
-  if (/-256(color)?$/i.test(env.TERM)) {
+  if (/-256(color)?$/i.test(env2.TERM)) {
     return 2;
   }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
     return 1;
   }
-  if ("COLORTERM" in env) {
+  if ("COLORTERM" in env2) {
     return 1;
   }
   return min;
@@ -187803,12 +187882,12 @@ var NO_ESCAPE_REGEXP = /^[\w./-]+$/;
 // node_modules/is-unicode-supported/index.js
 import process7 from "node:process";
 function isUnicodeSupported() {
-  const { env: env2 } = process7;
-  const { TERM, TERM_PROGRAM } = env2;
+  const { env: env3 } = process7;
+  const { TERM, TERM_PROGRAM } = env3;
   if (process7.platform !== "win32") {
     return TERM !== "linux";
   }
-  return Boolean(env2.WT_SESSION) || Boolean(env2.TERMINUS_SUBLIME) || env2.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env2.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  return Boolean(env3.WT_SESSION) || Boolean(env3.TERMINUS_SUBLIME) || env3.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env3.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 
 // node_modules/figures/index.js
@@ -188321,13 +188400,13 @@ import path12 from "node:path";
 // node_modules/npm-run-path/node_modules/path-key/index.js
 function pathKey(options = {}) {
   const {
-    env: env2 = process.env,
+    env: env3 = process.env,
     platform: platform6 = process.platform
   } = options;
   if (platform6 !== "win32") {
     return "PATH";
   }
-  return Object.keys(env2).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  return Object.keys(env3).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
 }
 
 // node_modules/npm-run-path/node_modules/unicorn-magic/node.js
@@ -188387,12 +188466,12 @@ var applyExecPath = (result, pathParts, execPath, cwdPath) => {
     result.push(pathPart);
   }
 };
-var npmRunPathEnv = ({ env: env2 = process8.env, ...options } = {}) => {
-  env2 = { ...env2 };
-  const pathName = pathKey({ env: env2 });
-  options.path = env2[pathName];
-  env2[pathName] = npmRunPath(options);
-  return env2;
+var npmRunPathEnv = ({ env: env3 = process8.env, ...options } = {}) => {
+  env3 = { ...env3 };
+  const pathName = pathKey({ env: env3 });
+  options.path = env3[pathName];
+  env3[pathName] = npmRunPath(options);
+  return env3;
 };
 
 // node_modules/execa/lib/terminate/kill.js
@@ -189741,17 +189820,17 @@ var addDefaultOptions = ({
   serialization
 });
 var getEnv = ({ env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath: nodePath2 }) => {
-  const env2 = extendEnv ? { ...process10.env, ...envOption } : envOption;
+  const env3 = extendEnv ? { ...process10.env, ...envOption } : envOption;
   if (preferLocal || node) {
     return npmRunPathEnv({
-      env: env2,
+      env: env3,
       cwd: localDirectory,
       execPath: nodePath2,
       preferLocal,
       addExecPath: node
     });
   }
-  return env2;
+  return env3;
 };
 
 // node_modules/execa/lib/arguments/shell.js
@@ -193958,7 +194037,7 @@ var {
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.0.34",
+  version: "0.0.35",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -195655,6 +195734,113 @@ function getLogsCommand(context) {
   });
 }
 
+// src/cli/commands/secrets/delete.ts
+async function deleteSecretsAction(keys) {
+  if (keys.length === 0) {
+    throw new InvalidInputError("Provide one or more secret names. Example: base44 secrets delete KEY1 KEY2");
+  }
+  for (const key of keys) {
+    await runTask(`Deleting secret "${key}"`, async () => {
+      return await deleteSecret(key);
+    }, {
+      successMessage: `Secret "${key}" deleted`,
+      errorMessage: `Failed to delete secret "${key}"`
+    });
+  }
+  R2.info(`Deleted: ${keys.join(", ")}`);
+  return {
+    outroMessage: "Secrets deleted. Your app will automatically redeploy with the updated values."
+  };
+}
+function getSecretsDeleteCommand(context) {
+  return new Command("delete").description("Delete one or more secrets").argument("[keys...]", "Secret name(s) to delete").action(async (keys) => {
+    await runCommand(() => deleteSecretsAction(keys), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/secrets/list.ts
+async function listSecretsAction() {
+  const secrets = await runTask("Fetching secrets from Base44", async () => {
+    return await listSecrets();
+  }, {
+    successMessage: "Secrets fetched successfully",
+    errorMessage: "Failed to fetch secrets"
+  });
+  const names = Object.keys(secrets);
+  if (names.length === 0) {
+    return { outroMessage: "No secrets configured." };
+  }
+  for (const [name2, maskedValue] of Object.entries(secrets)) {
+    R2.info(`${name2} = ${maskedValue}`);
+  }
+  return {
+    outroMessage: `Found ${names.length} secret${names.length === 1 ? "" : "s"}.`
+  };
+}
+function getSecretsListCommand(context) {
+  return new Command("list").description("List secret names (values are masked)").action(async () => {
+    await runCommand(listSecretsAction, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/secrets/set.ts
+function parseEntries(entries) {
+  const secrets = {};
+  for (const entry of entries) {
+    const eqIndex = entry.indexOf("=");
+    if (eqIndex === -1) {
+      throw new InvalidInputError(`Invalid format: "${entry}". Expected KEY=VALUE.`);
+    }
+    const key = entry.slice(0, eqIndex);
+    const value = entry.slice(eqIndex + 1);
+    if (!key) {
+      throw new InvalidInputError(`Invalid format: "${entry}". Key cannot be empty.`);
+    }
+    secrets[key] = value;
+  }
+  return secrets;
+}
+async function setSecretsAction(entries, options) {
+  const hasEntries = entries.length > 0;
+  const hasEnvFile = Boolean(options.envFile);
+  if (!hasEntries && !hasEnvFile) {
+    throw new InvalidInputError("Provide KEY=VALUE pairs or use --env-file. Example: base44 secrets set KEY1=VALUE1 KEY2=VALUE2");
+  }
+  if (hasEntries && hasEnvFile) {
+    throw new InvalidInputError("Provide KEY=VALUE pairs or --env-file, but not both.");
+  }
+  let secrets;
+  if (hasEnvFile) {
+    secrets = await parseEnvFile(options.envFile);
+    if (Object.keys(secrets).length === 0) {
+      throw new InvalidInputError("The env file contains no valid KEY=VALUE entries.");
+    }
+  } else {
+    secrets = parseEntries(entries);
+  }
+  const names = Object.keys(secrets);
+  await runTask(`Setting ${names.length} secret${names.length === 1 ? "" : "s"}`, async () => {
+    return await setSecrets(secrets);
+  }, {
+    successMessage: `${names.length} secret${names.length === 1 ? "" : "s"} set successfully`,
+    errorMessage: "Failed to set secrets"
+  });
+  R2.info(`Set: ${names.join(", ")}`);
+  return {
+    outroMessage: "Secrets saved. Your app will automatically redeploy with the new values."
+  };
+}
+function getSecretsSetCommand(context) {
+  return new Command("set").description("Set one or more secrets (KEY=VALUE format)").argument("[entries...]", "KEY=VALUE pairs (e.g. KEY1=VALUE1 KEY2=VALUE2)").option("--env-file <path>", "Path to .env file").action(async (entries, options) => {
+    await runCommand(() => setSecretsAction(entries, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/secrets/index.ts
+function getSecretsCommand(context) {
+  return new Command("secrets").description("Manage project secrets (environment variables)").addCommand(getSecretsListCommand(context)).addCommand(getSecretsSetCommand(context)).addCommand(getSecretsDeleteCommand(context));
+}
+
 // src/cli/commands/site/deploy.ts
 import { resolve as resolve3 } from "node:path";
 async function deployAction2(options) {
@@ -195770,9 +195956,9 @@ async function generateContent(input) {
 `);
 }
 async function compileEntity(entity2) {
-  const { name: name2, ...schema8 } = entity2;
+  const { name: name2, ...schema9 } = entity2;
   const jsonSchema = {
-    ...schema8,
+    ...schema9,
     title: name2,
     additionalProperties: false
   };
@@ -196373,6 +196559,7 @@ function createProgram(context) {
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsDeployCommand(context));
+  program2.addCommand(getSecretsCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
   program2.addCommand(getDevCommand(context), { hidden: true });
@@ -200641,4 +200828,4 @@ export {
   CLIExitError
 };
 
-//# debugId=E993552DEB874C2464756E2164756E21
+//# debugId=DB498D92DFB9A9A864756E2164756E21