@pikku/cli 0.12.0 → 0.12.2

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.d.ts

@@ -1,6 +1,11 @@
-import { TypesMap, ExternalPackageConfig } from '@pikku/inspector';
-import { Logger } from '@pikku/core/services';
+import type { TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+type WireAddonDeclarations = Map<string, {
+    package: string;
+    rpcEndpoint?: string;
+}>;
 export declare const serializeTypedRPCMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, rpcMeta: Record<string, string>, resolvedIOTypes: Record<string, {
     inputType: string;
     outputType: string;
-}>, externalPackages?: Record<string, ExternalPackageConfig>, workflowMapPath?: string, agentMapPath?: string) => string;
+}>, wireAddonDeclarations?: WireAddonDeclarations, workflowMapPath?: string, agentMapPath?: string) => string;
+export {};

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -1,6 +1,6 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes, } from '@pikku/inspector';
-export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, wireAddonDeclarations, workflowMapPath, agentMapPath) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedRPCs = generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes);
@@ -21,8 +21,8 @@ export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, ty
         .split('\n')
         .filter((line) => !line.startsWith('import '))
         .join('\n');
-    const externalPackageImports = generateExternalPackageImports(externalPackages, relativeToPath);
-    const mergedRPCMap = generateMergedRPCMap(externalPackages);
+    const addonImports = generateAddonImports(wireAddonDeclarations, relativeToPath);
+    const mergedRPCMap = generateMergedRPCMap(wireAddonDeclarations);
     return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
@@ -37,7 +37,7 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
-${externalPackageImports}
+${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
@@ -53,8 +53,8 @@ export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
 ${workflowMapPath ? `import type { WorkflowMap } from '${workflowMapPath}'` : `type WorkflowMap = {}`}
 
 ${agentMapPath ? `import type { AgentMap } from '${agentMapPath}'` : `type AgentMap = {}`}
-${generateExternalAgentImports(externalPackages)}
-${generateMergedAgentMap(externalPackages)}
+${generateAddonAgentImports(wireAddonDeclarations)}
+${generateMergedAgentMap(wireAddonDeclarations)}
 
 import type { PikkuRPC } from '@pikku/core/rpc'
 
@@ -64,36 +64,46 @@ interface AIAgentInput {
   resourceId: string
 }
 
-type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
+export type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
   name: Name,
   input: WorkflowMap[Name]['input'],
   options?: { startNode?: string }
 ) => Promise<{ runId: string }>
 
-type TypedAgent = <Name extends keyof FlattenedAgentMap>(
-  name: Name,
-  input: AIAgentInput
-) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+type TypedAgentRun = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput) => Promise<any>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput
+    ) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+
+type TypedAgentStream = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput, options?: { requiresToolApproval?: 'all' | 'explicit' | false }) => Promise<void>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput,
+      options?: { requiresToolApproval?: 'all' | 'explicit' | false }
+    ) => Promise<void>
 
-export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgent>
+export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgentRun, TypedAgentStream>
   `;
 };
-function generateExternalPackageImports(externalPackages, relativeToPath) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateAddonImports(wireAddonDeclarations, relativeToPath) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return '';
     }
-    let imports = '\n// External package RPC maps\n';
-    for (const [namespace, config] of Object.entries(externalPackages)) {
-        // Import the RPCMap from each external package's internal RPC map
+    let imports = '\n// Addon package RPC maps\n';
+    for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+        // Import the RPCMap from each addon package's internal RPC map
         // Use .js extension - package.json exports will resolve to .d.ts for types
-        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${config.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
+        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${decl.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
     }
     return imports;
 }
-function generateMergedRPCMap(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateMergedRPCMap(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return `
-// No external packages, use RPCMap directly
+// No addon packages, use RPCMap directly
 export type FlattenedRPCMap = RPCMap
 `;
     }
@@ -106,7 +116,7 @@ type PrefixKeys<T, Prefix extends string> = {
 
 // Merge all RPC maps with namespace prefixes
 export type FlattenedRPCMap =
-  RPCMap${Object.keys(externalPackages)
+  RPCMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
         .join('')}
 `;
@@ -118,25 +128,25 @@ function toPascalCase(str) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join('');
 }
-function generateExternalAgentImports(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateAddonAgentImports(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return '';
     }
-    let imports = '\n// External package Agent maps\n';
-    for (const [namespace, config] of Object.entries(externalPackages)) {
-        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${config.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
+    let imports = '\n// Addon package Agent maps\n';
+    for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${decl.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
     }
     return imports;
 }
-function generateMergedAgentMap(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateMergedAgentMap(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return `
 type FlattenedAgentMap = AgentMap
 `;
     }
     return `
 type FlattenedAgentMap =
-  AgentMap${Object.keys(externalPackages)
+  AgentMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}AgentMap, '${namespace}'>`)
         .join('')}
 `;

package/dist/src/functions/wirings/scheduler/serialize-scheduler-meta.d.ts

@@ -1,3 +1,3 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
 export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
 export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

package/dist/src/functions/wirings/secrets/serialize-secrets-types.d.ts

@@ -1,5 +1,5 @@
-import { SecretDefinitions } from '@pikku/core/secret';
-import { SchemaRef } from '@pikku/inspector';
+import type { SecretDefinitions } from '@pikku/core/secret';
+import type { SchemaRef } from '@pikku/inspector';
 export interface SerializeSecretsOptions {
     definitions: SecretDefinitions;
     schemaLookup: Map<string, SchemaRef>;

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.d.ts

@@ -1,4 +1,4 @@
-import { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
+import type { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
 export declare const serializeTriggerMeta: (triggerMeta: TriggerMeta) => TriggerMeta;
 export declare const serializeTriggerMetaTS: (triggerMeta: TriggerMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;
 export declare const serializeTriggerSourceMeta: (sourceMeta: TriggerSourceMeta) => TriggerSourceMeta;

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.js

@@ -6,7 +6,7 @@ export const serializeTriggerMetaTS = (triggerMeta, jsonImportPath, supportsImpo
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`;
     const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push("import { pikkuState } from '@pikku/core/internal'");
     serializedOutput.push("import { TriggerMeta } from '@pikku/core/trigger'");
     serializedOutput.push(importStatement);
     serializedOutput.push('');
@@ -26,7 +26,7 @@ export const serializeTriggerSourceMetaTS = (sourceMeta, jsonImportPath, support
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`;
     const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push("import { pikkuState } from '@pikku/core/internal'");
     serializedOutput.push("import { TriggerSourceMeta } from '@pikku/core/trigger'");
     serializedOutput.push(importStatement);
     serializedOutput.push('');

package/dist/src/functions/wirings/variables/serialize-variables-types.d.ts

@@ -1,5 +1,5 @@
-import { VariableDefinitions } from '@pikku/core/variable';
-import { SchemaRef } from '@pikku/inspector';
+import type { VariableDefinitions } from '@pikku/core/variable';
+import type { SchemaRef } from '@pikku/inspector';
 export interface SerializeVariablesOptions {
     definitions: VariableDefinitions;
     schemaLookup: Map<string, SchemaRef>;

package/dist/src/functions/wirings/workflow/pikku-command-workflow.js

@@ -37,25 +37,18 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
             }
         }
         if (workflowsWiringMetaFile && workflowMetaDir) {
-            await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflowsWiringMetaFile, workflowMetaDir, allWorkflowNames, packageMappings, schema?.supportsImportAttributes ?? false, config.externalPackageName));
+            await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflowsWiringMetaFile, workflowMetaDir, allWorkflowNames, packageMappings, schema?.supportsImportAttributes ?? false, config.addonName));
         }
         const metaImportPath = getFileImportRelativePath(workflowsWiringFile, workflowsWiringMetaFile, packageMappings);
-        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowRegistration(workflowsWiringFile, metaImportPath, allWorkflowNames, workflows.files, workflows.graphFiles, packageMappings, config.externalPackageName));
+        await writeFileInDir(logger, workflowsWiringFile, serializeWorkflowRegistration(workflowsWiringFile, metaImportPath, allWorkflowNames, workflows.files, workflows.graphFiles, packageMappings, config.addonName));
         const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
         await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta));
-        if (config.workflows) {
-            if (config.workflows.singleQueue) {
-                const workflowPath = join(config.rootDir, config.workflows.path);
-                const pathToPikkuTypes = getFileImportRelativePath(workflowPath, typesDeclarationFile, packageMappings);
-                await writeFileInDir(logger, workflowPath, serializeWorkflowWorkers(pathToPikkuTypes));
-            }
-            else if (workflows.files.size > 0) {
-                logger.critical(ErrorCode.WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED, 'Multi-queue workflows are not supported when workflows.singleQueue is false. Please enable singleQueue in your configuration.');
-                return false;
-            }
+        if (config.scaffold?.workflow) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.workflowWorkersFile, typesDeclarationFile, packageMappings);
+            await writeFileInDir(logger, config.workflowWorkersFile, serializeWorkflowWorkers(pathToPikkuTypes));
         }
         return hasWorkflows;
     },

package/dist/src/functions/wirings/workflow/serialize-workflow-map.d.ts

@@ -4,6 +4,6 @@
 import type { WorkflowsMeta } from '@pikku/core/workflow';
 import { type TypesMap } from '@pikku/inspector';
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph';
-import { FunctionsMeta } from '@pikku/core';
-import { Logger } from '@pikku/core/services';
+import type { FunctionsMeta } from '@pikku/core';
+import type { Logger } from '@pikku/core/services';
 export declare const serializeWorkflowMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, workflowsMeta: WorkflowsMeta, graphMeta: SerializedWorkflowGraphs) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.js

@@ -7,7 +7,7 @@ import { sanitizeTypeName } from '@pikku/inspector';
 export const serializeWorkflowMeta = (outputPath, metaDir, workflowNames, packageMappings, supportsImportAttributes, packageName) => {
     const pkg = packageName ? `'${packageName}'` : 'null';
     if (workflowNames.length === 0) {
-        return `import { pikkuState } from '@pikku/core'
+        return `import { pikkuState } from '@pikku/core/internal'
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'
 
 const workflowsMeta: SerializedWorkflowGraphs = {}
@@ -31,7 +31,7 @@ pikkuState(${pkg}, 'workflows', 'meta', workflowsMeta)`;
         return `  '${name}': ${sanitizedIdentifier}Meta,`;
     })
         .join('\n');
-    return `import { pikkuState } from '@pikku/core'
+    return `import { pikkuState } from '@pikku/core/internal'
 import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'
 
 ${imports}

package/dist/src/services/cli-logger-forwarder.service.d.ts

@@ -1,6 +1,7 @@
-import { Logger, LogLevel } from '@pikku/core/services';
-import { PikkuChannel } from '@pikku/core/channel';
-import { ErrorCode } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+import { LogLevel } from '@pikku/core/services';
+import type { PikkuChannel } from '@pikku/core/channel';
+import type { ErrorCode } from '@pikku/inspector';
 /**
  * Log message structure sent through the channel
  */

package/dist/src/services/cli-logger.service.d.ts

@@ -1,5 +1,6 @@
-import { Logger, LogLevel } from '@pikku/core/services';
-import { ErrorCode } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+import { LogLevel } from '@pikku/core/services';
+import type { ErrorCode } from '@pikku/inspector';
 export declare class CLILogger implements Logger {
     private silent;
     private level;

package/dist/src/services.d.ts

@@ -1,7 +1,8 @@
 import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
-import { CreateConfig, CreateWireServices, CreateSingletonServices } from '@pikku/core';
-import { PikkuCLIConfig } from '../types/config.js';
-import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
+import type { CreateConfig } from '@pikku/core';
+import type { CreateWireServices, CreateSingletonServices } from '@pikku/core/internal';
+import type { PikkuCLIConfig } from '../types/config.js';
+import type { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
 /**
  * Default CLI renderer that logs output using the logger
  */

package/dist/src/services.js

@@ -5,7 +5,8 @@ import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
 import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, getInitialInspectorState, ErrorCode, } from '@pikku/inspector';
 import { glob } from 'tinyglobby';
 import path from 'path';
-import { CLILoggerForwarder, } from './services/cli-logger-forwarder.service.js';
+import { CLILoggerForwarder } from './services/cli-logger-forwarder.service.js';
+import { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import { loadManifest } from './utils/contract-versions.js';
 import { join } from 'path';
@@ -202,6 +203,17 @@ export const createSingletonServices = async (config) => {
                 ignore: config.ignoreFiles || [],
                 absolute: true,
             })))).flat();
+            const scaffoldFiles = [
+                config.consoleFunctionsFile,
+                config.publicRpcFile,
+                config.publicAgentFile,
+                config.workflowWorkersFile,
+            ];
+            for (const file of scaffoldFiles) {
+                if (file && !wiringFiles.includes(file) && existsSync(file)) {
+                    wiringFiles.push(file);
+                }
+            }
             const manifest = !setupOnly
                 ? ((await loadManifest(join(config.outDir, 'versions.json'))) ??
                     undefined)
@@ -209,7 +221,7 @@ export const createSingletonServices = async (config) => {
             unfilteredState = await inspect(logger, wiringFiles, {
                 setupOnly,
                 rootDir,
-                isExternalPackage: config.externalPackage,
+                isAddon: config.addon,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
@@ -217,7 +229,6 @@ export const createSingletonServices = async (config) => {
                     wireServicesFactoryType: config.wireServicesFactoryType,
                 },
                 tags: config.tags,
-                externalPackages: config.externalPackages,
                 schemaConfig: !setupOnly
                     ? {
                         tsconfig: config.tsconfig,

package/dist/src/utils/check-required-types.d.ts

@@ -1,4 +1,4 @@
-import { FilesAndMethodsErrors } from '@pikku/inspector';
+import type { FilesAndMethodsErrors } from '@pikku/inspector';
 export type RequiredTypes = Partial<{
     config: boolean;
     wireServiceType: boolean;

package/dist/src/utils/contract-versions.d.ts

@@ -1,6 +1,6 @@
 import type { VersionManifest } from '@pikku/inspector';
 import { createEmptyManifest } from '@pikku/inspector';
 export { createEmptyManifest };
-export type { ContractEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from '@pikku/inspector';
+export type { ContractEntry, VersionHashEntry, VersionValidateError, VersionManifest, VersionManifestEntry, } from '@pikku/inspector';
 export declare function loadManifest(manifestPath: string): Promise<VersionManifest | null>;
 export declare function saveManifest(manifestPath: string, manifest: VersionManifest): Promise<void>;

package/dist/src/utils/file-writer.d.ts

@@ -1,9 +1,14 @@
-import { CLILogger } from '../services/cli-logger.service.js';
+import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const DO_NOT_MODIFY_COMMENT: string;
 export declare const writeFileInDir: (logger: CLILogger, path: string, content: string, { ignoreModifyComment, logWrite, }?: {
     ignoreModifyComment?: boolean;
     logWrite?: boolean;
 }) => Promise<void>;
+export declare function kebabCase(str: string): string;
+export declare function scaffoldFilePath(config: {
+    rootDir: string;
+    srcDirectories: string[];
+}, subdir: string, name: string, suffix: string, overrideDir?: string): string;
 export declare const removeFileInDir: (logger: CLILogger, path: string, { logRemove }?: {
     logRemove?: boolean;
 }) => Promise<void>;

package/dist/src/utils/file-writer.js

@@ -1,4 +1,4 @@
-import { dirname } from 'path';
+import { dirname, join } from 'path';
 import { mkdir, readFile, writeFile, rm } from 'fs/promises';
 import { existsSync } from 'fs';
 import { getCLIVersion } from './get-cli-version.js';
@@ -39,6 +39,19 @@ export const writeFileInDir = async (logger, path, content, { ignoreModifyCommen
         }
     }
 };
+export function kebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
+}
+export function scaffoldFilePath(config, subdir, name, suffix, overrideDir) {
+    const fileName = kebabCase(name);
+    if (overrideDir) {
+        return join(overrideDir, subdir, `${fileName}${suffix}`);
+    }
+    return join(config.rootDir, config.srcDirectories[0], subdir, `${fileName}${suffix}`);
+}
 export const removeFileInDir = async (logger, path, { logRemove = true } = {}) => {
     // Check if file exists before attempting removal
     if (existsSync(path)) {

package/dist/src/utils/generate-bootstrap-file.d.ts

@@ -1,3 +1,3 @@
-import { Config } from '../../types/application-types.js';
-import { CLILogger } from '../services/cli-logger.service.js';
+import type { Config } from '../../types/application-types.js';
+import type { CLILogger } from '../services/cli-logger.service.js';
 export declare const generateBootstrapFile: (logger: CLILogger, config: Config, bootstrapFile: string, specificImports: string[], schemas?: boolean, hasMiddleware?: boolean) => Promise<void>;

package/dist/src/utils/openapi/codegen.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generates addon files from a parsed OpenAPI spec.
+ * Returns Record<string, string> compatible with getAddonFiles output.
+ */
+import type { ParsedSpec } from './parse-openapi.js';
+interface AddonVars {
+    name: string;
+    camelName: string;
+    pascalName: string;
+    screamingName: string;
+    displayName: string;
+    description: string;
+}
+interface CodegenFlags {
+    oauth: boolean;
+    secret: boolean;
+}
+export declare function generateAddonFromOpenAPI(spec: ParsedSpec, vars: AddonVars, flags: CodegenFlags): Record<string, string>;
+export {};