feat: clean up multi-config matrix

packages/nuxt/src/module.ts

···
       config.watch = false;
     }
 
+    const output =
+      config.output instanceof Array ? config.output[0] : config.output;
     const folder = path.resolve(
       nuxt.options.rootDir,
-      typeof config.output === 'string' ? config.output : config.output.path,
+      typeof output === 'string' ? output : (output?.path ?? ''),
     );
 
     nuxt.options.alias[options.alias!] = folder;

packages/openapi-ts-tests/main/test/openapi-ts.config.ts

···
     // experimentalParser: false,
     input: [
       {
-        // branch: 'main',
         // fetch: {
         //   headers: {
         //     'x-foo': 'bar',
         //   },
         // },
-        // organization: 'hey-api',
         // path: {
         //   components: {},
         //   info: {
···
           // 'validators-circular-ref-2.yaml',
           // 'zoom-video-sdk.json',
         ),
-        // path: 'scalar:@scalar/access-service',
-        // path: 'hey-api/backend',
-        // path: 'hey-api/backend?branch=main&version=1.0.0',
         // path: 'https://get.heyapi.dev/hey-api/backend?branch=main&version=1.0.0',
         // path: 'http://localhost:4000/',
         // path: 'http://localhost:8000/openapi.json',
         // path: 'https://mongodb-mms-prod-build-server.s3.amazonaws.com/openapi/2caffd88277a4e27c95dcefc7e3b6a63a3b03297-v2-2023-11-15.json',
         // path: 'https://raw.githubusercontent.com/swagger-api/swagger-petstore/master/src/main/resources/openapi.yaml',
-        // project: 'backend',
-        // project: 'upload-openapi-spec',
-        // version: '1.0.0',
         // watch: {
         //   enabled: true,
         //   interval: 500,
         //   timeout: 30_000,
         // },
       },
-      path.resolve(getSpecsPath(), '3.1.x', 'full.yaml'),
+      // path.resolve(getSpecsPath(), '3.1.x', 'full.yaml'),
+      // {
+      //   branch: 'main',
+      //   organization: 'hey-api',
+      //   path: 'hey-api/backend',
+      //   project: 'backend',
+      //   project: 'upload-openapi-spec',
+      //   version: '1.0.0',
+      // },
+      // 'hey-api/backend?branch=main&version=1.0.0',
+      // 'scalar:@scalar/access-service',
+      // 'readme:@developers/v2.0#nysezql0wwo236',
+      // 'readme:nysezql0wwo236',
+      // 'https://dash.readme.com/api/v1/api-registry/nysezql0wwo236',
+      // 'https://somefakedomain.com/openapi.yaml',
     ],
     logs: {
-      level: 'debug',
+      // level: 'debug',
       path: './logs',
     },
     // name: 'foo',
-    output: {
-      // case: 'snake_case',
-      clean: true,
-      fileName: {
+    output: [
+      {
         // case: 'snake_case',
-        // name: '{{name}}.renamed',
-        suffix: '.meh',
+        clean: true,
+        fileName: {
+          // case: 'snake_case',
+          // name: '{{name}}.renamed',
+          suffix: '.meh',
+        },
+        // format: 'prettier',
+        importFileExtension: '.ts',
+        // indexFile: false,
+        // lint: 'eslint',
+        path: path.resolve(__dirname, 'generated', 'sample'),
+        tsConfigPath: path.resolve(
+          __dirname,
+          'tsconfig',
+          'tsconfig.nodenext.json',
+        ),
       },
-      // format: 'prettier',
-      importFileExtension: '.ts',
-      // indexFile: false,
-      // lint: 'eslint',
-      path: path.resolve(__dirname, 'generated', 'sample'),
-      tsConfigPath: path.resolve(
-        __dirname,
-        'tsconfig',
-        'tsconfig.nodenext.json',
-      ),
-    },
+      // path.resolve(__dirname, 'generated', 'sample2'),
+    ],
     parser: {
       filters: {
         // deprecated: false,

packages/openapi-ts/bin/index.cjs

···
   .option('-s, --silent', 'Set log level to silent')
   .option(
     '--no-log-file',
-    'Disable writing a log file. Works like --silent but without supressing console output',
+    'Disable writing a log file. Works like --silent but without suppressing console output',
   )
   .option(
     '-w, --watch [value]',
···
     }
 
     userConfig.logs.file = userConfig.logFile;
+    delete userConfig.logFile;
 
     if (typeof params.watch === 'string') {
       userConfig.watch = Number.parseInt(params.watch, 10);

packages/openapi-ts/src/__tests__/createClient.test.ts

···
   it('with platform string', () => {
     const path = compileInputPath({
       path: 'https://get.heyapi.dev/foo/bar?branch=main&commit_sha=sha&tags=a,b,c&version=1.0.0',
+      registry: 'hey-api',
     });
     expect(path).toEqual({
       branch: 'main',
···
       organization: 'foo',
       path: 'https://get.heyapi.dev/foo/bar?branch=main&commit_sha=sha&tags=a,b,c&version=1.0.0',
       project: 'bar',
+      registry: 'hey-api',
       tags: ['a', 'b', 'c'],
       version: '1.0.0',
     });
···
     process.env.HEY_API_TOKEN = 'foo';
     const path = compileInputPath({
       path: 'https://get.heyapi.dev/foo/bar',
+      registry: 'hey-api',
     });
     delete process.env.HEY_API_TOKEN;
     expect(path).toEqual({
···
       organization: 'foo',
       path: 'https://get.heyapi.dev/foo/bar?api_key=foo',
       project: 'bar',
+      registry: 'hey-api',
     });
   });
 });

packages/openapi-ts/src/__tests__/interactive.test.ts

···
 
 describe('interactive config', () => {
   it('should use detectInteractiveSession when not provided', async () => {
-    const result = await initConfigs({
-      input: 'test.json',
-      output: './test',
-    });
+    const result = await initConfigs([
+      {
+        input: 'test.json',
+        output: './test',
+      },
+    ]);
 
     // In test environment, TTY is typically not available, so it should be false
     expect(result.results[0]?.config.interactive).toBe(false);
   });
 
   it('should respect user config when set to true', async () => {
-    const result = await initConfigs({
-      input: 'test.json',
-      interactive: true,
-      output: './test',
-    });
+    const result = await initConfigs([
+      {
+        input: 'test.json',
+        interactive: true,
+        output: './test',
+      },
+    ]);
 
     expect(result.results[0]?.config.interactive).toBe(true);
   });
 
   it('should respect user config when set to false', async () => {
-    const result = await initConfigs({
-      input: 'test.json',
-      interactive: false,
-      output: './test',
-    });
+    const result = await initConfigs([
+      {
+        input: 'test.json',
+        interactive: false,
+        output: './test',
+      },
+    ]);
 
     expect(result.results[0]?.config.interactive).toBe(false);
   });

packages/openapi-ts/src/config/__tests__/input.test.ts

···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe('https://example.com/openapi.yaml');
     });
 
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/abc123',
       );
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/uuid123',
       );
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/test-uuid-123',
       );
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/abc123',
       );
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/uuid',
       );
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe('https://get.heyapi.dev/myorg/myproject');
     });
 
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toEqual({
         info: { title: 'Test API', version: '1.0.0' },
         openapi: '3.0.0',
···
 
       inputs.forEach((input) => {
         const userConfig: UserConfig = { input, output: 'src/client' };
-        const result = getInput(userConfig);
+        const result = getInput(userConfig)[0]!;
         expect(result.path).toBe(input);
       });
     });
···
         },
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/abc123',
       );
···
         output: 'src/client',
       };
 
-      const result = getInput(userConfig);
+      const result = getInput(userConfig)[0]!;
       expect(result.path).toBe(
         'https://dash.readme.com/api/v1/api-registry/test123',
       );

packages/openapi-ts/src/config/init.ts

···
 import path from 'node:path';
 
+import colors from 'ansi-colors';
 import { loadConfig } from 'c12';
 
 import { ConfigError } from '../error';
-import type {
-  Config,
-  UserConfig,
-  UserConfigMultiOutputs,
-} from '../types/config';
+import type { Config, UserConfig } from '../types/config';
 import { isLegacyClient, setConfig } from '../utils/config';
 import { getInput } from './input';
 import { getLogs } from './logs';
···
   );
 
 /**
- * Expands a UserConfig with multiple outputs into multiple UserConfigs with single outputs
- * @internal
- */
-const expandMultiOutputConfigs = (
-  userConfigs: ReadonlyArray<UserConfigMultiOutputs>,
-): ReadonlyArray<UserConfig> => {
-  const expandedConfigs: Array<UserConfig> = [];
-
-  for (const userConfig of userConfigs) {
-    if (Array.isArray(userConfig.output)) {
-      // Multi-output configuration - expand into multiple single-output configs
-      for (const output of userConfig.output) {
-        expandedConfigs.push({
-          ...userConfig,
-          output,
-        });
-      }
-    } else {
-      // Single output configuration - keep as is
-      expandedConfigs.push(userConfig as UserConfig);
-    }
-  }
-
-  return expandedConfigs;
-};
-
-/**
  * @internal
  */
 export const initConfigs = async (
-  userConfig:
-    | UserConfigMultiOutputs
-    | ReadonlyArray<UserConfigMultiOutputs>
-    | undefined,
+  userConfigs: ReadonlyArray<UserConfig>,
 ): Promise<{
   dependencies: Record<string, string>;
   results: ReadonlyArray<{
···
     errors: ReadonlyArray<Error>;
   }>;
 }> => {
-  let configurationFile: string | undefined = undefined;
-  if (userConfig && !(userConfig instanceof Array)) {
-    const cf = userConfig.configFile;
-    if (cf) {
-      const parts = cf.split('.');
+  const configs: Array<UserConfig> = [];
+  let dependencies: Record<string, string> = {};
+
+  for (const userConfig of userConfigs) {
+    let configurationFile: string | undefined = undefined;
+    if (userConfig?.configFile) {
+      const parts = userConfig.configFile.split('.');
       configurationFile = parts.slice(0, parts.length - 1).join('.');
     }
-  }
+
+    const { config: configFromFile, configFile: loadedConfigFile } =
+      await loadConfig<UserConfig>({
+        configFile: configurationFile,
+        name: 'openapi-ts',
+      });
+
+    if (!Object.keys(dependencies).length) {
+      // TODO: handle dependencies for multiple configs properly?
+      dependencies = getProjectDependencies(
+        Object.keys(configFromFile).length ? loadedConfigFile : undefined,
+      );
+    }
 
-  const { config: configFromFile, configFile: loadedConfigFile } =
-    await loadConfig<UserConfigMultiOutputs>({
-      configFile: configurationFile,
-      name: 'openapi-ts',
-    });
+    const mergedConfigs =
+      configFromFile instanceof Array
+        ? configFromFile.map((config) => mergeConfigs(config, userConfig))
+        : [mergeConfigs(configFromFile, userConfig)];
 
-  const dependencies = getProjectDependencies(
-    Object.keys(configFromFile).length ? loadedConfigFile : undefined,
-  );
-  const baseUserConfigs: ReadonlyArray<UserConfigMultiOutputs> = Array.isArray(
-    userConfig,
-  )
-    ? userConfig
-    : Array.isArray(configFromFile)
-      ? configFromFile.map((config) =>
-          mergeConfigs(config, userConfig as UserConfig | undefined),
-        )
-      : [
-          mergeConfigs(
-            (configFromFile as UserConfig) ?? ({} as UserConfig),
-            userConfig as UserConfig | undefined,
-          ),
-        ];
+    for (const mergedConfig of mergedConfigs) {
+      const input = getInput(mergedConfig);
 
-  // Expand multi-output configurations into multiple single-output configurations
-  const userConfigs = expandMultiOutputConfigs(baseUserConfigs);
+      if (mergedConfig.output instanceof Array) {
+        const countInputs = input.length;
+        const countOutputs = mergedConfig.output.length;
+        if (countOutputs > 1) {
+          if (countInputs !== countOutputs) {
+            console.warn(
+              `⚙️ ${colors.yellow('Warning:')} You provided ${colors.cyan(String(countInputs))} ${colors.cyan(countInputs === 1 ? 'input' : 'inputs')} and ${colors.yellow(String(countOutputs))} ${colors.yellow('outputs')}. This is probably not what you want as it will produce identical output in multiple locations. You most likely want to provide a single output or the same number of outputs as inputs.`,
+            );
+            for (const output of mergedConfig.output) {
+              configs.push({ ...mergedConfig, input, output });
+            }
+          } else {
+            mergedConfig.output.forEach((output, index) => {
+              configs.push({ ...mergedConfig, input: input[index]!, output });
+            });
+          }
+        } else {
+          configs.push({
+            ...mergedConfig,
+            input,
+            output: mergedConfig.output[0] ?? '',
+          });
+        }
+      } else {
+        configs.push({ ...mergedConfig, input });
+      }
+    }
+  }
 
   const results: Array<{
     config: Config;
     errors: Array<Error>;
   }> = [];
 
-  for (const userConfig of userConfigs) {
+  for (const userConfig of configs) {
     const {
       base,
       configFile = '',
···
     const output = getOutput(userConfig);
     const parser = getParser(userConfig);
 
-    if (!input.path) {
+    if (!input.length) {
       errors.push(
         new ConfigError(
           'missing input - which OpenAPI specification should we use to generate your output?',

packages/openapi-ts/src/config/input.ts

···
 import type { Config, UserConfig } from '../types/config';
-import type { Input } from '../types/input';
+import type { Input, Watch } from '../types/input';
 import { inputToApiRegistry } from '../utils/input';
 import { heyApiRegistryBaseUrl } from '../utils/input/heyApi';
 
-const defaultWatch: Config['input']['watch'] = {
+const defaultWatch: Watch = {
   enabled: false,
   interval: 1_000,
   timeout: 60_000,
 };
 
-const getWatch = (
-  input: Pick<Config['input'], 'path' | 'watch'>,
-): Config['input']['watch'] => {
+// watch only remote files
+const getWatch = (input: Pick<Input, 'path' | 'watch'>): Watch => {
   let watch = { ...defaultWatch };
 
   // we cannot watch spec passed as an object
···
 };
 
 export const getInput = (userConfig: UserConfig): Config['input'] => {
-  let input: Config['input'] = {
-    path: '',
-    watch: defaultWatch,
-  };
+  const userInputs =
+    userConfig.input instanceof Array ? userConfig.input : [userConfig.input];
 
-  if (typeof userConfig.input === 'string') {
-    input.path = userConfig.input;
-  } else if (
-    userConfig.input &&
-    !(userConfig.input instanceof Array) &&
-    (userConfig.input.path !== undefined ||
-      userConfig.input.organization !== undefined)
-  ) {
-    // @ts-expect-error
-    input = {
-      ...input,
-      path: heyApiRegistryBaseUrl,
-      ...userConfig.input,
+  const inputs: Array<Input> = [];
+
+  for (const userInput of userInputs) {
+    let input: Input = {
+      path: '',
+      watch: defaultWatch,
     };
 
-    // watch only remote files
-    if (input.watch !== undefined) {
-      input.watch = getWatch(input);
+    if (typeof userInput === 'string') {
+      input.path = userInput;
+    } else if (
+      userInput &&
+      (userInput.path !== undefined || userInput.organization !== undefined)
+    ) {
+      // @ts-expect-error
+      input = {
+        ...input,
+        path: heyApiRegistryBaseUrl,
+        ...userInput,
+      };
+
+      if (input.watch !== undefined) {
+        input.watch = getWatch(input);
+      }
+    } else {
+      input = {
+        ...input,
+        path: userInput,
+      };
+    }
+
+    if (typeof input.path === 'string') {
+      inputToApiRegistry(input as Input & { path: string });
     }
-  } else {
-    input = {
-      ...input,
-      path: userConfig.input as Record<string, unknown>,
-    };
-  }
 
-  if (typeof input.path === 'string') {
-    inputToApiRegistry(input as Input & { path: string });
-  }
+    if (
+      userConfig.watch !== undefined &&
+      input.watch.enabled === defaultWatch.enabled &&
+      input.watch.interval === defaultWatch.interval &&
+      input.watch.timeout === defaultWatch.timeout
+    ) {
+      input.watch = getWatch({
+        path: input.path,
+        // @ts-expect-error
+        watch: userConfig.watch,
+      });
+    }
 
-  if (
-    userConfig.watch !== undefined &&
-    input.watch.enabled === defaultWatch.enabled &&
-    input.watch.interval === defaultWatch.interval &&
-    input.watch.timeout === defaultWatch.timeout
-  ) {
-    input.watch = getWatch({
-      path: input.path,
-      // @ts-expect-error
-      watch: userConfig.watch,
-    });
+    if (input.path) {
+      inputs.push(input);
+    }
   }
 
-  return input;
+  return inputs;
 };

packages/openapi-ts/src/config/output.ts

···
 import { valueToObject } from './utils/config';
 
 export const getOutput = (userConfig: UserConfig): Config['output'] => {
+  if (userConfig.output instanceof Array) {
+    throw new Error(
+      'Unexpected array of outputs in user configuration. This should have been expanded already.',
+    );
+  }
+
   const output = valueToObject({
     defaultValue: {
       clean: true,

packages/openapi-ts/src/createClient.ts

···
 import path from 'node:path';
 
+import { $RefParser } from '@hey-api/json-schema-ref-parser';
 import colors from 'ansi-colors';
 
 import { generateLegacyOutput } from './generate/legacy/output';
···
 import { processOutput } from './processOutput';
 import type { Client } from './types/client';
 import type { Config } from './types/config';
+import type { Input } from './types/input';
 import type { WatchValues } from './types/types';
 import { isLegacyClient, legacyNameFromConfig } from './utils/config';
 import type { Templates } from './utils/handlebars';
-import { heyApiRegistryBaseUrl } from './utils/input/heyApi';
 import type { Logger } from './utils/logger';
 import { postProcessClient } from './utils/postprocess';
 
-const isHeyApiRegistryPath = (path: string) =>
-  path.startsWith(heyApiRegistryBaseUrl);
-// || path.startsWith('http://localhost:4000')
-
-export const compileInputPath = (input: Omit<Config['input'], 'watch'>) => {
+export const compileInputPath = (input: Omit<Input, 'watch'>) => {
   const result: Pick<
-    Partial<Config['input']>,
+    Partial<Input>,
     | 'api_key'
     | 'branch'
     | 'commit_sha'
     | 'organization'
     | 'project'
+    | 'registry'
     | 'tags'
     | 'version'
   > &
-    Pick<Required<Config['input']>, 'path'> = {
+    Pick<Input, 'path'> = {
+    ...input,
     path: '',
   };
 
   if (
     input.path &&
-    (typeof input.path !== 'string' || !isHeyApiRegistryPath(input.path))
+    (typeof input.path !== 'string' || input.registry !== 'hey-api')
   ) {
     result.path = input.path;
     return result;
···
   return result;
 };
 
-const logInputPath = (inputPath: ReturnType<typeof compileInputPath>) => {
-  const baseString = colors.cyan('Generating from');
+const logInputPaths = (
+  inputPaths: ReadonlyArray<ReturnType<typeof compileInputPath>>,
+  configIndex: number,
+) => {
+  const lines: Array<string> = [];
+
+  const jobIndexPrefix = colors.gray(`[Job ${configIndex + 1}] `);
+  const count = inputPaths.length;
+  const baseString = colors.cyan(
+    `Generating from ${count} ${count === 1 ? 'input' : 'inputs'}:`,
+  );
+  lines.push(`${jobIndexPrefix}⏳ ${baseString}`);
+
+  inputPaths.forEach((inputPath, index) => {
+    const inputIndexPrefixStr = `  [${index + 1}] `;
+    const inputIndexPrefix = colors.cyan(inputIndexPrefixStr);
+    const detailIndent = ' '.repeat(inputIndexPrefixStr.length);
+
+    if (typeof inputPath.path !== 'string') {
+      lines.push(
+        `${jobIndexPrefix}${inputIndexPrefix}raw OpenAPI specification`,
+      );
+      return;
+    }
 
-  if (typeof inputPath.path === 'string') {
-    const baseInput = isHeyApiRegistryPath(inputPath.path)
-      ? `${inputPath.organization ?? ''}/${inputPath.project ?? ''}`
-      : inputPath.path;
-    console.log(`⏳ ${baseString} ${baseInput}`);
-    if (isHeyApiRegistryPath(inputPath.path)) {
-      if (inputPath.branch) {
-        console.log(
-          `${colors.gray('branch:')} ${colors.green(inputPath.branch)}`,
-        );
-      }
-      if (inputPath.commit_sha) {
-        console.log(
-          `${colors.gray('commit:')} ${colors.green(inputPath.commit_sha)}`,
+    switch (inputPath.registry) {
+      case 'hey-api': {
+        const baseInput = [inputPath.organization, inputPath.project]
+          .filter(Boolean)
+          .join('/');
+        lines.push(`${jobIndexPrefix}${inputIndexPrefix}${baseInput}`);
+        if (inputPath.branch) {
+          lines.push(
+            `${jobIndexPrefix}${detailIndent}${colors.gray('branch:')} ${colors.green(
+              inputPath.branch,
+            )}`,
+          );
+        }
+        if (inputPath.commit_sha) {
+          lines.push(
+            `${jobIndexPrefix}${detailIndent}${colors.gray('commit:')} ${colors.green(
+              inputPath.commit_sha,
+            )}`,
+          );
+        }
+        if (inputPath.tags?.length) {
+          lines.push(
+            `${jobIndexPrefix}${detailIndent}${colors.gray('tags:')} ${colors.green(
+              inputPath.tags.join(', '),
+            )}`,
+          );
+        }
+        if (inputPath.version) {
+          lines.push(
+            `${jobIndexPrefix}${detailIndent}${colors.gray('version:')} ${colors.green(
+              inputPath.version,
+            )}`,
+          );
+        }
+        lines.push(
+          `${jobIndexPrefix}${detailIndent}${colors.gray('registry:')} ${colors.green('Hey API')}`,
         );
+        break;
       }
-      if (inputPath.tags?.length) {
-        console.log(
-          `${colors.gray('tags:')} ${colors.green(inputPath.tags.join(', '))}`,
+      case 'readme': {
+        const baseInput = [inputPath.organization, inputPath.project]
+          .filter(Boolean)
+          .join('/');
+        if (!baseInput) {
+          lines.push(`${jobIndexPrefix}${inputIndexPrefix}${inputPath.path}`);
+        } else {
+          lines.push(`${jobIndexPrefix}${inputIndexPrefix}${baseInput}`);
+        }
+        // @ts-expect-error
+        if (inputPath.uuid) {
+          lines.push(
+            `${jobIndexPrefix}${detailIndent}${colors.gray('uuid:')} ${colors.green(
+              // @ts-expect-error
+              inputPath.uuid,
+            )}`,
+          );
+        }
+        lines.push(
+          `${jobIndexPrefix}${detailIndent}${colors.gray('registry:')} ${colors.green('ReadMe')}`,
         );
+        break;
       }
-      if (inputPath.version) {
-        console.log(
-          `${colors.gray('version:')} ${colors.green(inputPath.version)}`,
+      case 'scalar': {
+        const baseInput = [inputPath.organization, inputPath.project]
+          .filter(Boolean)
+          .join('/');
+        lines.push(`${jobIndexPrefix}${inputIndexPrefix}${baseInput}`);
+        lines.push(
+          `${jobIndexPrefix}${detailIndent}${colors.gray('registry:')} ${colors.green('Scalar')}`,
         );
+        break;
       }
+      default:
+        lines.push(`${jobIndexPrefix}${inputIndexPrefix}${inputPath.path}`);
+        break;
     }
-  } else {
-    console.log(`⏳ ${baseString} raw OpenAPI specification`);
+  });
+
+  for (const line of lines) {
+    console.log(line);
   }
 };
 
 export const createClient = async ({
   config,
+  configIndex,
   dependencies,
   logger,
   templates,
-  watch: _watch,
+  watches: _watches,
 }: {
   config: Config;
+  configIndex: number;
   dependencies: Record<string, string>;
   logger: Logger;
   templates: Templates;
   /**
-   * Always falsy on the first run, truthy on subsequent runs.
+   * Always undefined on the first run, defined on subsequent runs.
    */
-  watch?: WatchValues;
-}) => {
-  // Support single or multiple input paths
-  const { watch: watchOptions, ...inputWithoutWatch } = config.input as Omit<
-    Config['input'],
-    'watch'
-  > & { watch: Config['input']['watch'] };
-  const inputPathsArray: Array<Config['input']['path']> = Array.isArray(
-    inputWithoutWatch.path,
-  )
-    ? (inputWithoutWatch.path as Array<Config['input']['path']>)
-    : [inputWithoutWatch.path as unknown as Config['input']['path']];
-  const compiledInputs = inputPathsArray.map((p) => {
-    if (typeof p === 'string') {
-      return compileInputPath({ ...inputWithoutWatch, path: p });
-    }
-    if (p && typeof p === 'object') {
-      // If the entry is an object (Input), spread it at the top level so we
-      // don't end up with a double-nested `path: { path: '...' }`.
-      return compileInputPath({ ...inputWithoutWatch, ...(p as any) });
-    }
-    return compileInputPath({ ...inputWithoutWatch, path: p as any });
-  });
-  const { timeout } = watchOptions;
+  watches?: ReadonlyArray<WatchValues>;
+}): Promise<Client | undefined | IR.Context> => {
+  const watches: ReadonlyArray<WatchValues> =
+    _watches ||
+    Array.from({ length: config.input.length }, () => ({
+      headers: new Headers(),
+    }));
 
-  const watch: WatchValues = _watch || { headers: new Headers(), inputs: {} };
+  const inputPaths = config.input.map((input) => compileInputPath(input));
 
   // on first run, print the message as soon as possible
-  if (config.logs.level !== 'silent' && !_watch) {
-    compiledInputs.forEach((ci) => logInputPath(ci));
+  if (config.logs.level !== 'silent' && !_watches) {
+    logInputPaths(inputPaths, configIndex);
   }
 
-  const eventSpec = logger.timeEvent('spec');
-  const { data, error, response } = await getSpec({
-    fetchOptions: config.input.fetch,
-    inputPaths: compiledInputs.map((ci) => ci.path),
-    timeout,
-    watch,
-  });
-  eventSpec.timeEnd();
+  const getSpecData = async (input: Input, index: number) => {
+    const eventSpec = logger.timeEvent('spec');
+    const { arrayBuffer, error, resolvedInput, response } = await getSpec({
+      fetchOptions: input.fetch,
+      inputPath: inputPaths[index]!.path,
+      timeout: input.watch.timeout,
+      watch: watches[index]!,
+    });
+    eventSpec.timeEnd();
+
+    // throw on first run if there's an error to preserve user experience
+    // if in watch mode, subsequent errors won't throw to gracefully handle
+    // cases where server might be reloading
+    if (error && !_watches) {
+      throw new Error(
+        `Request failed with status ${response.status}: ${response.statusText}`,
+      );
+    }
 
-  // throw on first run if there's an error to preserve user experience
-  // if in watch mode, subsequent errors won't throw to gracefully handle
-  // cases where server might be reloading
-  if (error && !_watch) {
-    throw new Error(
-      `Request failed with status ${response.status}: ${response.statusText}`,
-    );
-  }
+    return { arrayBuffer, resolvedInput };
+  };
+  const specData = (
+    await Promise.all(
+      config.input.map((input, index) => getSpecData(input, index)),
+    )
+  ).filter((data) => data.arrayBuffer || data.resolvedInput);
 
   let client: Client | undefined;
   let context: IR.Context | undefined;
 
-  if (data) {
-    // on subsequent runs in watch mode, print the mssage only if we know we're
+  if (specData.length) {
+    const refParser = new $RefParser();
+    const data =
+      specData.length > 1
+        ? await refParser.bundleMany({
+            arrayBuffer: specData.map((data) => data.arrayBuffer!),
+            pathOrUrlOrSchemas: [],
+            resolvedInputs: specData.map((data) => data.resolvedInput!),
+          })
+        : await refParser.bundle({
+            arrayBuffer: specData[0]!.arrayBuffer,
+            pathOrUrlOrSchema: undefined,
+            resolvedInput: specData[0]!.resolvedInput,
+          });
+
+    // on subsequent runs in watch mode, print the message only if we know we're
     // generating the output
-    if (config.logs.level !== 'silent' && _watch) {
+    if (config.logs.level !== 'silent' && _watches) {
       console.clear();
-      compiledInputs.forEach((ci) => logInputPath(ci));
+      logInputPaths(inputPaths, configIndex);
     }
 
     const eventInputPatch = logger.timeEvent('input.patch');
···
         const outputPath = process.env.INIT_CWD
           ? `./${path.relative(process.env.INIT_CWD, config.output.path)}`
           : config.output.path;
+        const jobPrefix =
+          typeof configIndex === 'number'
+            ? colors.gray(`[Job ${configIndex + 1}] `)
+            : '';
         console.log(
-          `${colors.green('🚀 Done!')} Your output is in ${colors.cyanBright(outputPath)}`,
+          `${jobPrefix}${colors.green('🚀 Done!')} Your output is in ${colors.cyanBright(outputPath)}`,
         );
       }
     }
     eventPostprocess.timeEnd();
   }
 
-  if (
-    config.input.watch.enabled &&
-    compiledInputs.some((ci) => typeof ci.path === 'string')
-  ) {
+  const watchedInput = config.input.find(
+    (input, index) =>
+      input.watch.enabled && typeof inputPaths[index]!.path === 'string',
+  );
+
+  if (watchedInput) {
     setTimeout(() => {
-      createClient({ config, dependencies, logger, templates, watch });
-    }, config.input.watch.interval);
+      createClient({
+        config,
+        configIndex,
+        dependencies,
+        logger,
+        templates,
+        watches,
+      });
+    }, watchedInput.watch.interval);
   }
 
   return context || client;

packages/openapi-ts/src/debug/ir.ts

···
     if (verbosity === 'summary' && obj && typeof obj === 'object') {
       if (kind === 'responses') {
         const count = Object.keys(obj).length;
-        const noun = count !== 1 ? 'codes' : 'code';
+        const noun = count === 1 ? 'code' : 'codes';
         log(`responses: ${colors.yellow(`${count} ${noun}`)}`, level);
       } else if (kind === 'requestBody') {
         log(`requestBody: ${Object.keys(obj).join(', ')}`, level);

packages/openapi-ts/src/getSpec.ts

···
-import {
-  $RefParser,
-  getResolvedInput,
-  type JSONSchema,
-  sendRequest,
-} from '@hey-api/json-schema-ref-parser';
+import { getResolvedInput, sendRequest } from '@hey-api/json-schema-ref-parser';
 
 import { mergeHeaders } from './plugins/@hey-api/client-fetch/bundle';
-import type { Config } from './types/config';
+import type { Input } from './types/input';
 import type { WatchValues } from './types/types';
 
-interface SpecResponse {
-  data: JSONSchema;
-  error?: undefined;
-  response?: undefined;
-}
+type SpecResponse = {
+  arrayBuffer: ArrayBuffer | undefined;
+  error?: never;
+  resolvedInput: ReturnType<typeof getResolvedInput>;
+  response?: never;
+};
 
-interface SpecError {
-  data?: undefined;
+type SpecError = {
+  arrayBuffer?: never;
   error: 'not-modified' | 'not-ok';
+  resolvedInput?: never;
   response: Response;
-}
+};
 
 /**
  * @internal
  */
 export const getSpec = async ({
   fetchOptions,
-  inputPaths,
+  inputPath,
   timeout,
   watch,
 }: {
   fetchOptions?: RequestInit;
-  inputPaths: Array<Config['input']['path']>;
+  inputPath: Input['path'];
   timeout: number | undefined;
   watch: WatchValues;
 }): Promise<SpecResponse | SpecError> => {
-  const refParser = new $RefParser();
-  const resolvedInputs = inputPaths.map((inputPath) =>
-    getResolvedInput({ pathOrUrlOrSchema: inputPath }),
-  );
+  const resolvedInput = getResolvedInput({ pathOrUrlOrSchema: inputPath });
 
-  const arrayBuffer: ArrayBuffer[] = [];
-  let anyChanged = false;
-  let lastResponse: Response | undefined;
-  watch.inputs = watch.inputs || {};
-
-  for (const resolvedInput of resolvedInputs) {
-    let hasChanged: boolean | undefined;
-    let response: Response | undefined;
+  let arrayBuffer: ArrayBuffer | undefined;
+  // boolean signals whether the file has **definitely** changed
+  let hasChanged: boolean | undefined;
+  let response: Response | undefined;
 
-    const key = `${resolvedInput.type}:${resolvedInput.path ?? ''}`;
-    const state = (watch.inputs[key] = watch.inputs[key] || {
-      headers: new Headers(),
-    });
-
-    if (resolvedInput.type === 'url') {
-      if (state.lastValue && state.isHeadMethodSupported !== false) {
-        try {
-          const request = await sendRequest({
-            fetchOptions: {
-              method: 'HEAD',
-              ...fetchOptions,
-              headers: mergeHeaders(fetchOptions?.headers, state.headers),
-            },
-            timeout,
-            url: resolvedInput.path,
-          });
-
-          lastResponse = request.response;
-
-          if (request.response.status >= 300) {
-            return {
-              error: 'not-ok',
-              response: request.response,
-            };
-          }
-
-          response = request.response;
-        } catch (error) {
-          return {
-            error: 'not-ok',
-            response: new Response((error as Error).message),
-          };
-        }
-
-        if (response.status === 304) {
-          hasChanged = false;
-        } else if (!response.ok && state.isHeadMethodSupported) {
-          return {
-            error: 'not-ok',
-            response,
-          };
-        }
-
-        if (state.isHeadMethodSupported === undefined) {
-          state.isHeadMethodSupported = response.ok;
-        }
-
-        if (hasChanged === undefined) {
-          const eTag = response.headers.get('ETag');
-          if (eTag) {
-            hasChanged = eTag !== state.headers.get('If-None-Match');
-            if (hasChanged) {
-              state.headers.set('If-None-Match', eTag);
-            } else {
-              // Definitely not changed based on ETag
-              hasChanged = false;
-            }
-          }
-        }
-
-        if (hasChanged === undefined) {
-          const lastModified = response.headers.get('Last-Modified');
-          if (lastModified) {
-            hasChanged =
-              lastModified !== state.headers.get('If-Modified-Since');
-            if (hasChanged) {
-              state.headers.set('If-Modified-Since', lastModified);
-            } else {
-              hasChanged = false;
-            }
-          }
-        }
-
-        if (hasChanged === false && state.lastValue !== undefined) {
-          // Use cached content without GET
-          const encoded = new TextEncoder().encode(state.lastValue);
-          const cachedBuffer = new ArrayBuffer(encoded.byteLength);
-          new Uint8Array(cachedBuffer).set(encoded);
-          arrayBuffer.push(cachedBuffer);
-          anyChanged = anyChanged || false;
-          continue;
-        }
-      }
-
+  if (resolvedInput.type === 'url') {
+    // do NOT send HEAD request on first run or if unsupported
+    if (watch.lastValue && watch.isHeadMethodSupported !== false) {
       try {
         const request = await sendRequest({
           fetchOptions: {
-            method: 'GET',
+            method: 'HEAD',
             ...fetchOptions,
+            headers: mergeHeaders(fetchOptions?.headers, watch.headers),
           },
           timeout,
           url: resolvedInput.path,
         });
 
-        lastResponse = request.response;
-
         if (request.response.status >= 300) {
           return {
             error: 'not-ok',
···
       } catch (error) {
         return {
           error: 'not-ok',
-          response: new Response((error as Error).message),
+          response: new Response(error.message),
         };
       }
 
-      if (!response.ok) {
+      if (!response.ok && watch.isHeadMethodSupported) {
+        // assume the server is no longer running
+        // do nothing, it might be restarted later
         return {
           error: 'not-ok',
           response,
         };
       }
 
-      const lastBuffer = response.body
-        ? await response.arrayBuffer()
-        : new ArrayBuffer(0);
-      arrayBuffer.push(lastBuffer);
+      if (watch.isHeadMethodSupported === undefined) {
+        watch.isHeadMethodSupported = response.ok;
+      }
+
+      if (response.status === 304) {
+        return {
+          error: 'not-modified',
+          response,
+        };
+      }
+
+      if (hasChanged === undefined) {
+        const eTag = response.headers.get('ETag');
+        if (eTag) {
+          hasChanged = eTag !== watch.headers.get('If-None-Match');
+
+          if (hasChanged) {
+            watch.headers.set('If-None-Match', eTag);
+          }
+        }
+      }
 
       if (hasChanged === undefined) {
-        const content = new TextDecoder().decode(lastBuffer);
-        hasChanged = content !== state.lastValue;
-        state.lastValue = content;
-      } else if (hasChanged) {
-        // Update lastValue since it changed
-        const content = new TextDecoder().decode(lastBuffer);
-        state.lastValue = content;
+        const lastModified = response.headers.get('Last-Modified');
+        if (lastModified) {
+          hasChanged = lastModified !== watch.headers.get('If-Modified-Since');
+
+          if (hasChanged) {
+            watch.headers.set('If-Modified-Since', lastModified);
+          }
+        }
       }
-    } else {
-      // we do not support watch mode for files or raw spec data
-      if (!state.lastValue) {
-        state.lastValue = resolvedInput.type;
-      } else {
-        hasChanged = false;
+
+      // we definitely know the input has not changed
+      if (hasChanged === false) {
+        return {
+          error: 'not-modified',
+          response,
+        };
       }
-      // Maintain alignment with resolvedInputs
-      arrayBuffer.push(new ArrayBuffer(0));
     }
 
-    anyChanged = anyChanged || hasChanged !== false;
-  }
+    try {
+      const request = await sendRequest({
+        fetchOptions: {
+          method: 'GET',
+          ...fetchOptions,
+        },
+        timeout,
+        url: resolvedInput.path,
+      });
 
-  let data: JSONSchema;
-  if (resolvedInputs.length === 1) {
-    data = await refParser.bundle({
-      arrayBuffer: arrayBuffer[0],
-      pathOrUrlOrSchema: undefined,
-      resolvedInput: resolvedInputs[0],
-    });
+      if (request.response.status >= 300) {
+        return {
+          error: 'not-ok',
+          response: request.response,
+        };
+      }
+
+      response = request.response;
+    } catch (error) {
+      return {
+        error: 'not-ok',
+        response: new Response(error.message),
+      };
+    }
+
+    if (!response.ok) {
+      // assume the server is no longer running
+      // do nothing, it might be restarted later
+      return {
+        error: 'not-ok',
+        response,
+      };
+    }
+
+    arrayBuffer = response.body
+      ? await response.arrayBuffer()
+      : new ArrayBuffer(0);
+
+    if (hasChanged === undefined) {
+      const content = new TextDecoder().decode(arrayBuffer);
+      hasChanged = content !== watch.lastValue;
+      watch.lastValue = content;
+    }
   } else {
-    data = await refParser.bundleMany({
-      arrayBuffer,
-      pathOrUrlOrSchemas: [],
-      resolvedInputs,
-    });
+    // we do not support watch mode for files or raw spec data
+    if (!watch.lastValue) {
+      watch.lastValue = resolvedInput.type;
+    } else {
+      hasChanged = false;
+    }
   }
-  if (!anyChanged) {
+
+  if (hasChanged === false) {
     return {
       error: 'not-modified',
-      response: lastResponse || new Response('', { status: 304 }),
-    } as SpecError;
+      response: response!,
+    };
   }
-  return { data };
+
+  return {
+    arrayBuffer,
+    resolvedInput,
+  };
 };

packages/openapi-ts/src/index.ts

···
 
 import { checkNodeVersion } from './config/engine';
 import { initConfigs } from './config/init';
+import { getLogs } from './config/logs';
 import { createClient as pCreateClient } from './createClient';
 import {
   logCrashReport,
···
 } from './error';
 import type { IR } from './ir/types';
 import type { Client } from './types/client';
-import type { Config, UserConfigMultiOutputs } from './types/config';
+import type { Config, UserConfig } from './types/config';
+import type { LazyOrAsync, MaybeArray } from './types/utils';
 import { registerHandlebarTemplates } from './utils/handlebars';
 import { Logger } from './utils/logger';
 
-type ConfigValue =
-  | UserConfigMultiOutputs
-  | ReadonlyArray<UserConfigMultiOutputs>;
-// Generic input shape for config that may be a value or a (possibly async) factory
-type ConfigInput<T extends ConfigValue> = T | (() => T) | (() => Promise<T>);
-
 colors.enabled = colorSupport().hasBasic;
 
 /**
  * Generate a client from the provided configuration.
  *
- * @param userConfig User provided {@link UserConfigMultiOutputs} configuration.
+ * @param userConfig User provided {@link UserConfig} configuration(s).
  */
 export const createClient = async (
-  userConfig?: ConfigInput<ConfigValue>,
+  userConfig?: LazyOrAsync<MaybeArray<UserConfig>>,
   logger = new Logger(),
 ): Promise<ReadonlyArray<Client | IR.Context>> => {
   const resolvedConfig =
     typeof userConfig === 'function' ? await userConfig() : userConfig;
+  const userConfigs = resolvedConfig
+    ? resolvedConfig instanceof Array
+      ? resolvedConfig
+      : [resolvedConfig]
+    : [];
 
   const configs: Array<Config> = [];
 
···
     const eventCreateClient = logger.timeEvent('createClient');
 
     const eventConfig = logger.timeEvent('config');
-    const configResults = await initConfigs(resolvedConfig);
-
-    // Check for configuration errors and fail immediately
+    const configResults = await initConfigs(userConfigs);
     for (const result of configResults.results) {
       configs.push(result.config);
       if (result.errors.length) {
···
     eventHandlebars.timeEnd();
 
     const clients = await Promise.all(
-      configs.map((config) =>
+      configs.map((config, index) =>
         pCreateClient({
           config,
+          configIndex: index,
           dependencies: configResults.dependencies,
           logger,
           templates,
···
 
     return result;
   } catch (error) {
-    // Handle both configuration errors and runtime errors
-    // For multi-config scenarios, use first available config or reasonable defaults
-    const firstConfig = configs[0];
-    const resolvedSingle = (
-      Array.isArray(resolvedConfig) ? resolvedConfig[0] : resolvedConfig
-    ) as UserConfigMultiOutputs | undefined;
-
-    const logs = firstConfig?.logs ?? {
-      file: false,
-      level: 'warn' as const,
-      path: '',
-    };
-    const dryRun = firstConfig?.dryRun ?? resolvedSingle?.dryRun ?? false;
+    const resolvedConfig = userConfigs[0];
+    const config = configs[0];
+    const dryRun = config?.dryRun ?? resolvedConfig?.dryRun ?? false;
     const isInteractive =
-      firstConfig?.interactive ?? resolvedSingle?.interactive ?? false;
+      config?.interactive ?? resolvedConfig?.interactive ?? false;
+    const logs = config?.logs ?? getLogs(resolvedConfig);
 
     let logPath: string | undefined;
 
···
 };
 
 /**
- * Type helper for openapi-ts.config.ts, returns {@link ConfigValue} object
+ * Type helper for openapi-ts.config.ts, returns {@link MaybeArray<UserConfig>} object(s)
  */
-export const defineConfig = async <T extends ConfigValue>(
-  config: ConfigInput<T>,
+export const defineConfig = async <T extends MaybeArray<UserConfig>>(
+  config: LazyOrAsync<T>,
 ): Promise<T> => (typeof config === 'function' ? await config() : config);
 
 export { defaultPaginationKeywords } from './config/parser';

packages/openapi-ts/src/openApi/2.0.x/parser/schema.ts

···
     const isEmptyObjectInAllOf =
       state.inAllOf &&
       schema.additionalProperties === false &&
-      (!schema.properties || Object.keys(schema.properties).length === 0);
+      (!schema.properties || !Object.keys(schema.properties).length);
 
     if (!isEmptyObjectInAllOf) {
       irSchema.additionalProperties = {

packages/openapi-ts/src/openApi/3.0.x/parser/schema.ts

···
     const isEmptyObjectInAllOf =
       state.inAllOf &&
       schema.additionalProperties === false &&
-      (!schema.properties || Object.keys(schema.properties).length === 0);
+      (!schema.properties || !Object.keys(schema.properties).length);
 
     if (!isEmptyObjectInAllOf) {
       irSchema.additionalProperties = {

packages/openapi-ts/src/openApi/3.1.x/parser/schema.ts

···
     const isEmptyObjectInAllOf =
       state.inAllOf &&
       schema.additionalProperties === false &&
-      (!schema.properties || Object.keys(schema.properties).length === 0) &&
+      (!schema.properties || !Object.keys(schema.properties).length) &&
       (!schema.patternProperties ||
-        Object.keys(schema.patternProperties).length === 0);
+        !Object.keys(schema.patternProperties).length);
 
     if (!isEmptyObjectInAllOf) {
       irSchema.additionalProperties = {

packages/openapi-ts/src/openApi/3.1.x/types/json-schema-draft-2020-12.d.ts

···
+import type { MaybeArray } from '../../../types/utils';
 import type { EnumExtensions } from '../../shared/types/openapi-spec-extensions';
 import type { OpenApiSchemaExtensions } from './spec-extensions';
 
···
   /**
    * If it is an array, it must be an array of strings, where each string is the name of one of the basic types, and each element is unique. In this case, the JSON snippet is valid if it matches any of the given types.
    */
-  type?: JsonSchemaTypes | ReadonlyArray<JsonSchemaTypes>;
+  type?: MaybeArray<JsonSchemaTypes>;
   /**
    * The boolean keywords `readOnly` and `writeOnly` are typically used in an API context. `readOnly` indicates that a value should not be modified. It could be used to indicate that a `PUT` request that changes a value would result in a `400 Bad Request` response. `writeOnly` indicates that a value may be set, but will remain hidden. In could be used to indicate you can set a value with a `PUT` request, but it would not be included when retrieving that record with a `GET` request.
    */

packages/openapi-ts/src/openApi/shared/transforms/readWrite.ts

···
             (prop) => !removedProperties.has(prop),
           );
 
-          if (filteredRequired.length === 0) {
+          if (!filteredRequired.length) {
             delete (schema as Record<string, unknown>).required;
           } else {
             (schema as Record<string, unknown>).required = filteredRequired;

packages/openapi-ts/src/types/config.d.ts

···
 import type { PluginConfigMap } from '../plugins/config';
 import type { Plugin, PluginNames } from '../plugins/types';
-import type { Input, InputPath, Watch } from './input';
+import type { Input, UserInput, Watch } from './input';
 import type { Logs } from './logs';
 import type { Output, UserOutput } from './output';
 import type { Parser, UserParser } from './parser';
+import type { MaybeArray } from './utils';
 
-export interface UserConfigMultiOutputs extends Omit<UserConfig, 'output'> {
-  output: string | UserOutput | ReadonlyArray<string | UserOutput>;
-}
 export interface UserConfig {
   /**
    * Path to the config file. Set this value if you don't use the default
···
    * object directly if you're fetching the file yourself.
    *
    * Alternatively, you can define a configuration object with more options.
+   *
+   * If you define an array, we will generate a single output from multiple
+   * inputs. If you define an array of outputs with the same length, we will
+   * generate multiple outputs, one for each input.
    */
-  input: InputPath | Input | ReadonlyArray<InputPath | Input>;
+  input: MaybeArray<UserInput | Required<UserInput>['path']>;
   /**
    * Show an interactive error reporting tool when the program crashes? You
    * generally want to keep this disabled (default).
···
    */
   logs?: string | Logs;
   /**
-   * Path to the output folder. You can define an array to generate
-   * multiple outputs from your input.
+   * Path to the output folder.
+   *
+   * If you define an array of outputs with the same length as inputs, we will
+   * generate multiple outputs, one for each input.
    */
-  output: string | UserOutput;
+  output: MaybeArray<string | UserOutput>;
   /**
    * Customize how the input is parsed and transformed before it's passed to
    * plugins.
···
   | 'watch'
 > &
   Pick<UserConfig, 'base' | 'name' | 'request'> & {
-    input: Omit<Input, 'path' | 'watch'> &
-      Pick<Required<Input>, 'path'> & { watch: Watch };
+    /**
+     * Path to the input specification.
+     */
+    input: ReadonlyArray<Input>;
     logs: Logs;
+    /**
+     * Path to the output folder.
+     */
     output: Output;
     /**
      * Customize how the input is parsed and transformed before it's passed to

packages/openapi-ts/src/types/input.d.ts

···
-export type InputPath =
+type JsonSchema = Record<string, unknown>;
+
+type ApiRegistryShorthands =
   | `https://get.heyapi.dev/${string}/${string}`
   | `${string}/${string}`
   | `readme:@${string}/${string}#${string}`
   | `readme:${string}`
-  | `scalar:@${string}/${string}`
-  | (string & {})
-  | Record<string, unknown>;
+  | `scalar:@${string}/${string}`;
 
-export type Input = {
+export type UserInput = {
   /**
    * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
    *
···
    * Both JSON and YAML file formats are supported. You can also pass the parsed
    * object directly if you're fetching the file yourself.
    */
-  path?: InputPath;
+  path?: ApiRegistryShorthands | (string & {}) | JsonSchema;
   /**
    * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
    *
···
    * @default false
    */
   watch?: boolean | number | Watch;
+};
+
+export type Input = {
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * Projects are private by default, you will need to be authenticated
+   * to download OpenAPI specifications. We recommend using project API
+   * keys in CI workflows and personal API keys for local development.
+   *
+   * API key isn't required for public projects. You can also omit this
+   * parameter and provide an environment variable `HEY_API_TOKEN`.
+   */
+  api_key?: string;
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * You can fetch the last build from branch by providing the branch
+   * name.
+   */
+  branch?: string;
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * You can fetch an exact specification by providing a commit sha.
+   * This will always return the same file.
+   */
+  commit_sha?: string;
+  /**
+   * You can pass any valid Fetch API options to the request for fetching your
+   * specification. This is useful if your file is behind auth for example.
+   */
+  fetch?: RequestInit;
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * Organization created in Hey API Platform.
+   */
+  organization?: string;
+  /**
+   * Path to the OpenAPI specification. This can be:
+   *   - path
+   *   - URL
+   *   - API registry shorthand
+   *
+   * Both JSON and YAML file formats are supported. You can also pass the parsed
+   * object directly if you're fetching the file yourself.
+   */
+  path: ApiRegistryShorthands | (string & {}) | JsonSchema;
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * Project created in Hey API Platform.
+   */
+  project?: string;
+  /**
+   * If input path was resolved to a registry, this contains the registry
+   * identifier so we don't need to parse it again.
+   *
+   * @default undefined
+   */
+  registry?: 'hey-api' | 'readme' | 'scalar';
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * If you're tagging your specifications with custom tags, you can use
+   * them to filter the results. When you provide multiple tags, only
+   * the first match will be returned.
+   */
+  tags?: ReadonlyArray<string>;
+  /**
+   * **Requires `path` to start with `https://get.heyapi.dev` or be undefined**
+   *
+   * Every OpenAPI document contains a required version field. You can
+   * use this value to fetch the last uploaded specification matching
+   * the value.
+   */
+  version?: string;
+  /**
+   * Regenerate the client when the input file changes? You can alternatively
+   * pass a numeric value for the interval in ms.
+   */
+  watch: Watch;
 };
 
 export type Watch = {

packages/openapi-ts/src/types/types.d.ts

···
    */
   headers: Headers;
   /**
-   * Per-input watch state for multi-input mode. Keys should be a stable
-   * identifier for the input (typically the URL or file path).
-   */
-  inputs?: Record<
-    string,
-    {
-      headers: Headers;
-      isHeadMethodSupported?: boolean;
-      lastValue?: string;
-    }
-  >;
-  /**
    * Can we send a HEAD request instead of fetching the whole specification?
    * This value will be set after the first successful fetch.
    */

packages/openapi-ts/src/types/utils.d.ts

···
 };
 
 export type Files = Record<string, GeneratedFile>;
+
+export type LazyOrAsync<T> = T | (() => T) | (() => Promise<T>);
+
+export type MaybeArray<T> = T | ReadonlyArray<T>;

packages/openapi-ts/src/utils/input/__tests__/readme.test.ts

···
   describe('inputToReadmePath', () => {
     it('should transform simple UUID format to API URL', () => {
       const result = inputToReadmePath('readme:abc123');
-      expect(result).toBe('https://dash.readme.com/api/v1/api-registry/abc123');
+      expect(result).toEqual({
+        path: 'https://dash.readme.com/api/v1/api-registry/abc123',
+        registry: 'readme',
+        uuid: 'abc123',
+      });
     });
 
     it('should transform full format to API URL', () => {
       const result = inputToReadmePath('readme:@myorg/myproject#uuid123');
-      expect(result).toBe(
-        'https://dash.readme.com/api/v1/api-registry/uuid123',
-      );
+      expect(result).toEqual({
+        organization: 'myorg',
+        path: 'https://dash.readme.com/api/v1/api-registry/uuid123',
+        project: 'myproject',
+        registry: 'readme',
+        uuid: 'uuid123',
+      });
     });
 
     it('should throw error for invalid inputs', () => {
···
       'should handle $input correctly',
       ({ expected, input }) => {
         expect(parseShorthand(input)).toEqual(expected);
-        expect(inputToReadmePath(`readme:${input}`)).toBe(
-          `https://dash.readme.com/api/v1/api-registry/${expected.uuid}`,
-        );
+        expect(inputToReadmePath(`readme:${input}`)).toEqual({
+          organization: expected.organization,
+          path: `https://dash.readme.com/api/v1/api-registry/${expected.uuid}`,
+          project: expected.project,
+          registry: 'readme',
+          uuid: expected.uuid,
+        });
       },
     );
 

packages/openapi-ts/src/utils/input/__tests__/scalar.test.ts

···
   describe('inputToScalarPath', () => {
     it('should transform full format to API URL', () => {
       const result = inputToScalarPath('scalar:@foo/bar');
-      expect(result).toBe(
-        'https://registry.scalar.com/@foo/apis/bar/latest?format=json',
-      );
+      expect(result).toEqual({
+        organization: '@foo',
+        path: 'https://registry.scalar.com/@foo/apis/bar/latest?format=json',
+        project: 'bar',
+        registry: 'scalar',
+      });
     });
 
     it('should throw error for invalid inputs', () => {
···
       'should handle $input correctly',
       ({ expected, input }) => {
         expect(parseShorthand(input)).toEqual(expected);
-        expect(inputToScalarPath(`scalar:${input}`)).toBe(
-          `https://registry.scalar.com/${expected.organization}/apis/${expected.project}/latest?format=json`,
-        );
+        expect(inputToScalarPath(`scalar:${input}`)).toEqual({
+          organization: expected.organization,
+          path: `https://registry.scalar.com/${expected.organization}/apis/${expected.project}/latest?format=json`,
+          project: expected.project,
+          registry: 'scalar',
+        });
       },
     );
 

packages/openapi-ts/src/utils/input/heyApi.ts

···
-// Regular expression to match Hey API Registry input formats:
-
 import type { Input } from '../../types/input';
 
+// Regular expression to match Hey API Registry input formats:
 //   - {organization}/{project}?{queryParams}
 const registryRegExp = /^([\w-]+)\/([\w-]+)(?:\?([\w=&.-]*))?$/;
 
···
  * @throws Error if the input format is invalid
  */
 export const parseShorthand = (
-  input: Omit<Input, 'path'> & {
+  input: Input & {
     path: string;
   },
 ): Parsed => {
···
  * @returns The Hey API Registry URL
  */
 export const inputToHeyApiPath = (
-  input: Omit<Input, 'path'> & {
+  input: Input & {
     path: string;
   },
-): string => {
+): Partial<Input> => {
   const parsed = parseShorthand(input);
-  return getRegistryUrl(
-    parsed.organization,
-    parsed.project,
-    parsed.queryParams,
-  );
+  return {
+    path: getRegistryUrl(
+      parsed.organization,
+      parsed.project,
+      parsed.queryParams,
+    ),
+    registry: 'hey-api',
+  };
 };

packages/openapi-ts/src/utils/input/index.ts

···
   },
 ) => {
   if (input.path.startsWith('readme:')) {
-    input.path = inputToReadmePath(input.path);
+    Object.assign(input, inputToReadmePath(input.path));
     return;
   }
 
   if (input.path.startsWith('scalar:')) {
-    input.path = inputToScalarPath(input.path);
+    Object.assign(input, inputToScalarPath(input.path));
     return;
   }
 
···
 
   if (input.path.startsWith(heyApiRegistryBaseUrl)) {
     input.path = input.path.slice(heyApiRegistryBaseUrl.length + 1);
-    input.path = inputToHeyApiPath(input as Input & { path: string });
+    Object.assign(input, inputToHeyApiPath(input as Input & { path: string }));
     return;
   }
 
   const parts = input.path.split('/');
-  const cleanParts = parts.filter(Boolean);
-  if (parts.length === 2 && cleanParts.length === 2) {
-    input.path = inputToHeyApiPath(input as Input & { path: string });
+  if (parts.length === 2 && parts.filter(Boolean).length === 2) {
+    Object.assign(input, inputToHeyApiPath(input as Input & { path: string }));
+    return;
   }
 };

packages/openapi-ts/src/utils/input/readme.ts

···
+import type { Input } from '../../types/input';
+
 // Regular expression to match ReadMe API Registry input formats:
 //   - @{organization}/{project}#{uuid}
 //   - {uuid}
···
  * @param input - ReadMe format string
  * @returns The ReadMe API Registry URL
  */
-export const inputToReadmePath = (input: string): string => {
+export const inputToReadmePath = (input: string): Partial<Input> => {
   const shorthand = input.slice(`${namespace}:`.length);
   const parsed = parseShorthand(shorthand);
-  return getRegistryUrl(parsed.uuid);
+  return {
+    ...parsed,
+    path: getRegistryUrl(parsed.uuid),
+    registry: 'readme',
+  };
 };

packages/openapi-ts/src/utils/input/scalar.ts

···
+import type { Input } from '../../types/input';
+
 // Regular expression to match Scalar API Registry input formats:
 //   - @{organization}/{project}
 const registryRegExp = /^(@[\w-]+)\/([\w.-]+)$/;
···
  * @param input - Scalar format string
  * @returns The Scalar API Registry URL
  */
-export const inputToScalarPath = (input: string): string => {
+export const inputToScalarPath = (input: string): Partial<Input> => {
   const shorthand = input.slice(`${namespace}:`.length);
   const parsed = parseShorthand(shorthand);
-  return getRegistryUrl(parsed.organization, parsed.project);
+  return {
+    ...parsed,
+    path: getRegistryUrl(parsed.organization, parsed.project),
+    registry: 'scalar',
+  };
 };