@fern-api/fern-api-dev 5.21.1 → 5.22.0-6-g27bd77bb4a2

package/cli.cjs

@@ -40040,12 +40040,15 @@ var require_data = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+// ../../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js
 var require_utils16 = __commonJS({
-  "../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js"(exports2, module4) {
+  "../../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js"(exports2, module4) {
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input3) {
       let acc = "";
       let code5 = 0;
@@ -40238,27 +40241,77 @@ var require_utils16 = __commonJS({
       }
       return output2.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func2 = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func2(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func2(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func2(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP3) {
+      const re10 = isIP3 ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re10.lastIndex = 0;
+      return host.replace(re10, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input3, decodeUnreserved = false) {
+      if (input3.indexOf("%") === -1) {
+        return input3;
       }
-      if (component.path !== void 0) {
-        component.path = func2(component.path);
+      let output2 = "";
+      for (let i9 = 0; i9 < input3.length; i9++) {
+        if (input3[i9] === "%" && i9 + 2 < input3.length) {
+          const hex3 = input3.slice(i9 + 1, i9 + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output2 += decoded;
+            } else {
+              output2 += "%" + normalizedHex;
+            }
+            i9 += 2;
+            continue;
+          }
+        }
+        output2 += input3[i9];
       }
-      if (component.query !== void 0) {
-        component.query = func2(component.query);
+      return output2;
+    }
+    function normalizePathEncoding(input3) {
+      let output2 = "";
+      for (let i9 = 0; i9 < input3.length; i9++) {
+        if (input3[i9] === "%" && i9 + 2 < input3.length) {
+          const hex3 = input3.slice(i9 + 1, i9 + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output2 += decoded;
+            } else {
+              output2 += "%" + normalizedHex;
+            }
+            i9 += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input3[i9])) {
+          output2 += input3[i9];
+        } else {
+          output2 += escape(input3[i9]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func2(component.fragment);
+      return output2;
+    }
+    function escapePreservingEscapes(input3) {
+      let output2 = "";
+      for (let i9 = 0; i9 < input3.length; i9++) {
+        if (input3[i9] === "%" && i9 + 2 < input3.length) {
+          const hex3 = input3.slice(i9 + 1, i9 + 3);
+          if (isHexPair(hex3)) {
+            output2 += "%" + hex3.toUpperCase();
+            i9 += 2;
+            continue;
+          }
+        }
+        output2 += escape(input3[i9]);
       }
-      return component;
+      return output2;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -40273,7 +40326,7 @@ var require_utils16 = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -40287,7 +40340,10 @@ var require_utils16 = __commonJS({
     module4.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -40297,9 +40353,9 @@ var require_utils16 = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
+// ../../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS({
-  "../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js"(exports2, module4) {
+  "../../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js"(exports2, module4) {
     "use strict";
     var { isUUID } = require_utils16();
     var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
@@ -40507,16 +40563,16 @@ var require_schemes = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js
+// ../../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS({
-  "../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js"(exports2, module4) {
+  "../../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js"(exports2, module4) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils16();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils16();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize13(uri, options2) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize5(parse19(uri, options2), options2);
+        normalizeString(uri, options2);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse19(serialize5(uri, options2), options2);
@@ -40583,19 +40639,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options2) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize5(normalizeComponentEncoding(parse19(uriA, options2), true), { ...options2, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize5(normalizeComponentEncoding(uriA, true), { ...options2, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize5(normalizeComponentEncoding(parse19(uriB, options2), true), { ...options2, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize5(normalizeComponentEncoding(uriB, true), { ...options2, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options2);
+      const normalizedB = normalizeComparableURI(uriB, options2);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize5(cmpts, opts) {
       const component = {
@@ -40620,12 +40666,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options2);
       if (component.path !== void 0) {
         if (!options2.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options2.reference !== "suffix" && component.scheme) {
@@ -40660,7 +40706,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse19(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options2 = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -40671,6 +40726,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP3 = false;
       if (options2.reference === "suffix") {
         if (options2.scheme) {
@@ -40691,6 +40747,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -40729,14 +40790,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP3);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -40745,7 +40810,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse19(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize5(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize5(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -661252,7 +661339,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.21.1",
+          version: "5.22.0-6-g27bd77bb4a2",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -661307,7 +661394,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.21.1",
+        version: "5.22.0-6-g27bd77bb4a2",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -852580,7 +852667,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.21.1";
+  const version7 = "5.22.0-6-g27bd77bb4a2";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -865389,7 +865476,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.21.1",
+        cliVersion: "5.22.0-6-g27bd77bb4a2",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -920086,6 +920173,180 @@ function addGenerateCommand(cli) {
   }));
 }
 
+// ../cli-v2/lib/commands/sdk/list/command.js
+var import_generators_sdk4 = __toESM(require_generators_sdk(), 1);
+var GENERATOR_TYPES = ["sdk", "model", "server"];
+var ListCommand2 = class {
+  async handle(context3, args) {
+    const configuredTargets = await this.loadConfiguredTargets(context3);
+    const languageFilter = args.language != null ? this.parseLanguageFilter(args.language) : void 0;
+    const typeFilter = args.type != null ? this.parseTypeFilter(args.type) : void 0;
+    const availableGenerators = await this.fetchAvailableGenerators({ context: context3, languageFilter, typeFilter });
+    if (args.json) {
+      this.printJson({ context: context3, configuredTargets, availableGenerators, languageFilter, typeFilter });
+      return;
+    }
+    this.printHuman({ context: context3, configuredTargets, availableGenerators, languageFilter, typeFilter });
+  }
+  async loadConfiguredTargets(context3) {
+    const result = await context3.loadWorkspace();
+    if (result == null || !result.success) {
+      if (result != null && !result.success) {
+        context3.stderr.warn(source_default.dim("  Warning: Could not load fern.yml \u2014 showing unconfigured generators only."));
+      }
+      return [];
+    }
+    return result.workspace.sdks?.targets ?? [];
+  }
+  async fetchAvailableGenerators({ context: context3, languageFilter, typeFilter }) {
+    const fdrOrigin = "https://registry-dev2.buildwithfern.com";
+    const client3 = new import_generators_sdk4.FernRegistryClient({ environment: fdrOrigin });
+    try {
+      const response = await client3.generators.listGenerators();
+      if (!response.ok) {
+        context3.stderr.warn(source_default.dim("  Could not fetch available generators from registry."));
+        return [];
+      }
+      let generators = response.body;
+      if (languageFilter != null) {
+        generators = generators.filter((g8) => g8.generatorLanguage === languageFilter);
+      }
+      if (typeFilter != null) {
+        generators = generators.filter((g8) => g8.generatorType.type === typeFilter);
+      }
+      return generators;
+    } catch {
+      context3.stderr.warn(source_default.dim("  Could not fetch available generators from registry (network error)."));
+      return [];
+    }
+  }
+  printJson({ context: context3, configuredTargets, availableGenerators, languageFilter, typeFilter }) {
+    const filteredTargets = this.filterConfiguredTargets({
+      targets: configuredTargets,
+      languageFilter,
+      typeFilter
+    });
+    const configured = filteredTargets.map((t3) => ({
+      name: t3.name,
+      language: t3.lang,
+      version: t3.version,
+      output: this.formatOutput(t3),
+      groups: t3.groups ?? [],
+      image: t3.image
+    }));
+    const configuredImages = new Set(configuredTargets.map((t3) => t3.image));
+    const available = availableGenerators.filter((g8) => !configuredImages.has(g8.dockerImage)).map((g8) => ({
+      id: g8.id,
+      displayName: g8.displayName,
+      type: g8.generatorType.type,
+      language: g8.generatorLanguage ?? null,
+      dockerImage: g8.dockerImage
+    }));
+    context3.stdout.info(JSON.stringify({ configured, available }, null, 2));
+  }
+  printHuman({ context: context3, configuredTargets, availableGenerators, languageFilter, typeFilter }) {
+    const filteredTargets = this.filterConfiguredTargets({
+      targets: configuredTargets,
+      languageFilter,
+      typeFilter
+    });
+    if (filteredTargets.length > 0) {
+      context3.stderr.info(`${Icons.info} ${source_default.cyan("Configured SDKs:")}`);
+      context3.stderr.info("");
+      for (const target of filteredTargets) {
+        const version7 = source_default.dim(`v${target.version}`.padEnd(20));
+        const output2 = source_default.dim(`\u2192 ${this.formatOutput(target)}`);
+        const groups2 = target.groups != null && target.groups.length > 0 ? source_default.dim(` [${target.groups.join(", ")}]`) : "";
+        const displayName = LANGUAGE_DISPLAY_NAMES[target.lang];
+        context3.stderr.info(`  ${source_default.white(displayName.padEnd(14))} ${version7} ${output2}${groups2}`);
+      }
+    } else if (languageFilter == null && typeFilter == null) {
+      context3.stderr.info(source_default.dim("No SDK targets configured."));
+    } else if (typeFilter != null && typeFilter !== "sdk") {
+      context3.stderr.info(source_default.dim("Configured targets are always of type 'sdk'; none match the given type filter."));
+    } else {
+      context3.stderr.info(source_default.dim("No configured SDK targets match the given filters."));
+    }
+    const configuredImages = new Set(configuredTargets.map((t3) => t3.image));
+    const unconfigured = availableGenerators.filter((g8) => !configuredImages.has(g8.dockerImage));
+    if (unconfigured.length > 0) {
+      context3.stderr.info("");
+      context3.stderr.info(`${Icons.info} ${source_default.cyan("Available (not configured):")}`);
+      context3.stderr.info("");
+      for (const gen of unconfigured) {
+        const lang = gen.generatorLanguage != null ? source_default.dim(gen.generatorLanguage.padEnd(12)) : source_default.dim("".padEnd(12));
+        const type8 = source_default.dim(`[${gen.generatorType.type}]`);
+        context3.stderr.info(`  ${source_default.white(gen.displayName.padEnd(20))} ${lang} ${type8}`);
+      }
+      context3.stderr.info("");
+      context3.stderr.info(source_default.dim("  Run 'fern sdk add --target <language>' to add a new SDK."));
+    } else if (availableGenerators.length > 0) {
+      context3.stderr.info("");
+      context3.stderr.info(source_default.dim("  All available generators are already configured."));
+    }
+  }
+  filterConfiguredTargets({ targets: targets2, languageFilter, typeFilter }) {
+    let filtered = targets2;
+    if (languageFilter != null) {
+      filtered = filtered.filter((t3) => t3.lang === languageFilter);
+    }
+    if (typeFilter != null) {
+      if (typeFilter !== "sdk") {
+        return [];
+      }
+    }
+    return filtered;
+  }
+  formatOutput(target) {
+    if (target.output.git != null) {
+      const git = target.output.git;
+      if (schemas_exports13.isGitOutputGitHubRepository(git)) {
+        return git.repository;
+      }
+      if (schemas_exports13.isGitOutputSelfHosted(git)) {
+        return git.uri;
+      }
+    }
+    return target.output.path ?? "./";
+  }
+  parseLanguageFilter(value2) {
+    const lang = LANGUAGES.find((l9) => l9 === value2.toLowerCase());
+    if (lang != null) {
+      return lang;
+    }
+    const supported = LANGUAGES.join(", ");
+    throw new CliError({
+      message: `"${value2}" is not a supported language. Supported: ${supported}`,
+      code: CliError.Code.ConfigError
+    });
+  }
+  parseTypeFilter(value2) {
+    const type8 = GENERATOR_TYPES.find((t3) => t3 === value2.toLowerCase());
+    if (type8 != null) {
+      return type8;
+    }
+    const supported = GENERATOR_TYPES.join(", ");
+    throw new CliError({
+      message: `"${value2}" is not a supported generator type. Supported: ${supported}`,
+      code: CliError.Code.ConfigError
+    });
+  }
+};
+function addListCommand2(cli) {
+  const cmd = new ListCommand2();
+  command2(cli, "list", "List configured and available SDK generators", (context3, args) => cmd.handle(context3, args), (yargs) => yargs.option("language", {
+    type: "string",
+    description: "Filter by language (e.g. typescript, python, go)"
+  }).option("type", {
+    type: "string",
+    description: "Filter by generator type (sdk, model, server)"
+  }).option("json", {
+    type: "boolean",
+    default: false,
+    description: "Output results as JSON to stdout"
+  }));
+}
+
 // ../cli-v2/lib/commands/sdk/preview/command.js
 var PreviewCommand2 = class {
   generateCommand = new GenerateCommand();
@@ -920725,6 +920986,7 @@ function addSdkCommand(cli) {
     addAddCommand,
     addCheckCommand4,
     addGenerateCommand,
+    addListCommand2,
     addPreviewCommand2,
     addUpdateCommand
   ]);
@@ -939694,7 +939956,7 @@ var InteractiveTaskContextImpl = class extends TaskContextImpl {
 };
 
 // src/cli-context/upgrade-utils/getFernUpgradeMessage.ts
-var import_generators_sdk4 = __toESM(require_generators_sdk(), 1);
+var import_generators_sdk5 = __toESM(require_generators_sdk(), 1);
 function hasGeneratorUpgrade(generatorUpgradeInfo) {
   return generatorUpgradeInfo.filter((gui) => gui.isUpgradeAvailable).length > 0;
 }
@@ -939770,7 +940032,7 @@ ${await normalizeGeneratorName2(generatorUpgrade.generatorName)} (${generatorUpg
   }) : message;
 }
 async function normalizeGeneratorName2(generatorImage) {
-  const client3 = new import_generators_sdk4.FernRegistryClient({
+  const client3 = new import_generators_sdk5.FernRegistryClient({
     environment: "https://registry-dev2.buildwithfern.com"
   });
   const generatorResponse = await client3.generators.getGeneratorByImage({ dockerImage: generatorImage });
@@ -940017,7 +940279,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.21.1";
+    return "5.22.0-6-g27bd77bb4a2";
   }
   getCliName() {
     if (false) {
@@ -940472,7 +940734,7 @@ async function loadProjectAndRegisterWorkspacesWithContext(cliContext, args, reg
 }
 
 // src/cliV2.ts
-var import_generators_sdk5 = __toESM(require_generators_sdk(), 1);
+var import_generators_sdk6 = __toESM(require_generators_sdk(), 1);
 var import_promises142 = require("fs/promises");
 
 // src/commands/generator-list/getGeneratorList.ts
@@ -941404,7 +941666,7 @@ function addGeneratorCommands(cli, cliContext) {
         description: "Whether or not to include major versions within the upgrade. Defaults to false, meaning major versions will be skipped."
       }).option("channel", {
         demandOption: false,
-        choices: Object.values(import_generators_sdk5.FernRegistry.generators.ReleaseType)
+        choices: Object.values(import_generators_sdk6.FernRegistry.generators.ReleaseType)
       }).option("list", {
         demandOption: false,
         boolean: true,

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.21.1",
+  "version": "5.22.0-6-g27bd77bb4a2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",