@pikku/cli 0.6.20 → 0.7.0

package/dist/src/core/serialize-pikku-types.js

@@ -6,7 +6,8 @@ export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName,
 * This is used to provide the application types in the typescript project
 */
   
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, PikkuMiddleware, MakeRequired } from '@pikku/core'
+import { CorePermissionGroup, CoreAPIPermission, PikkuMiddleware, MakeRequired } from '@pikku/core'
+import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/function'
 import { CoreHTTPFunctionRoute, AssertRouteParams, addRoute as addCoreHTTP } from '@pikku/core/http'
 import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
 import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
@@ -18,17 +19,100 @@ ${sessionServicesTypeImport}
 export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
 export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
 
-export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
-export type APIFunction<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
-type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
+type APIFunctionSessionless<In = unknown, Out = never, Channel extends boolean = false, RequiredServices extends Services = Services & (Channel extends true ? { channel: PikkuChannel<unknown, Out> } : { channel?: PikkuChannel<unknown, Out> })> = CoreAPIFunctionSessionless<In, Out, Channel, RequiredServices, ${userSessionTypeName}>
+type APIFunction<In = unknown, Out = never, Channel extends boolean = false, RequiredServices extends Services = Services & (Channel extends true ? { channel: PikkuChannel<unknown, Out> } : { channel?: PikkuChannel<unknown, Out> })> = CoreAPIFunction<In, Out, Channel, RequiredServices, ${userSessionTypeName}>
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, CorePermissionGroup<APIPermission>, APIMiddleware>
 
 export type ChannelConnection<Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<RequiredServices, 'userSession'>, channel: PikkuChannel<ChannelData, Out>) => Promise<void>
 export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<RequiredServices, 'userSession'>, channel: PikkuChannel<ChannelData, never>) => Promise<void>
-export type ChannelMessage<In, Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<RequiredServices, 'userSession'>, channel: PikkuChannel<ChannelData, Out>, data: In) => Promise<Out | void>
-type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<any, any, ChannelData>, ChannelMessage<any, any, ChannelData>, APIPermission>
+type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<any, any, false> | APIFunction<any, any, true>, APIPermission>
 
 type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
 
+export const pikkuFunc = <In, Out = unknown>(
+  func:
+    | APIFunction<In, Out>
+    | {
+        func: APIFunction<In, Out>
+        auth?: true
+        name?: string
+      }
+    | {
+        func: APIFunctionSessionless<In, Out>
+        auth: false
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out>
+    | {
+        func: APIFunctionSessionless<In, Out>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelConnection = <In, Out = unknown>(
+  func:
+    | ChannelConnection<In, Out>
+    | {
+        func: ChannelConnection<In, Out>
+        auth?: true
+        name?: string
+      }
+    | {
+        func: ChannelConnection<In, Out>
+        auth: false
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelDisconnection = <In>(
+  func:
+    | ChannelDisconnection<In>
+    | {
+        func: ChannelDisconnection<In>
+        auth?: true
+        name?: string
+      }
+    | {
+        func: ChannelDisconnection<In>
+        auth: false
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelFunc = <In, Out = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out, true>
+    | {
+        func: APIFunctionSessionless<In, Out, true>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuVoidFunc = (
+  func:
+    | APIFunctionSessionless<void, void>
+    | {
+        func: APIFunctionSessionless<void, void>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+   
 export const addChannel = <ChannelData, Channel extends string>(
   channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
 ) => {

package/dist/src/events/channels/serialize-channels.d.ts

@@ -0,0 +1,3 @@
+import { ChannelsMeta } from '@pikku/core/channel';
+export declare const serializeChannels: (outputPath: string, filesWithChannels: Set<string>, packageMappings?: Record<string, string>) => string;
+export declare const serializeChannelMeta: (channelsMeta: ChannelsMeta) => string;

package/dist/src/events/channels/serialize-channels.js

@@ -0,0 +1,19 @@
+import { getFileImportRelativePath } from '../utils.js';
+export const serializeChannels = (outputPath, filesWithChannels, packageMappings = {}) => {
+    const serializedOutput = [
+        '/* The files with an addChannel function call */',
+    ];
+    Array.from(filesWithChannels)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};
+export const serializeChannelMeta = (channelsMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('channel', 'meta', ${JSON.stringify(channelsMeta, null, 2)})`);
+    return serializedOutput.join('\n');
+};

package/dist/src/events/channels/serialize-typed-channel-map.d.ts

@@ -0,0 +1,3 @@
+import { ChannelsMeta } from '@pikku/core/channel';
+import { TypesMap } from '@pikku/inspector';
+export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, channelsMeta: ChannelsMeta) => string;

package/dist/src/events/channels/serialize-typed-channel-map.js

@@ -0,0 +1,90 @@
+import { serializeImportMap } from '../core/serialize-import-map.js';
+import { generateCustomTypes } from '../http/serialize-typed-route-map.js';
+export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
+    const { channels, requiredTypes } = generateChannels(channelsMeta);
+    typesMap.customTypes.forEach(({ references }) => {
+        for (const reference of references) {
+            requiredTypes.add(reference);
+        }
+    });
+    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for TypeScript to be aware of channels
+ */
+    
+${imports}
+${serializedCustomTypes}
+
+interface ChannelHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${channels}
+
+export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
+    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
+        ? ChannelHandler<I, O>
+        : never;
+
+export type ChannelRouteHandlerOf<
+    Channel extends keyof ChannelsMap, 
+    Route extends keyof ChannelsMap[Channel]['routes'], 
+    Method extends keyof ChannelsMap[Channel]['routes'][Route],
+> =
+    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
+        ? ChannelHandler<I, O>
+        : never;
+`;
+};
+function generateChannels(channelsMeta) {
+    const requiredTypes = new Set();
+    const channelsObject = {};
+    for (const meta of channelsMeta) {
+        const { name, messageRoutes, message } = meta;
+        if (!channelsObject[name]) {
+            channelsObject[name] = { message, routes: {} };
+        }
+        for (const [key, route] of Object.entries(messageRoutes)) {
+            if (!channelsObject[name].routes[key]) {
+                channelsObject[name].routes[key] = {};
+            }
+            for (const [method, { inputs, outputs }] of Object.entries(route)) {
+                const inputTypes = inputs || null;
+                const outputTypes = outputs || null;
+                channelsObject[name].routes[key][method] = {
+                    inputTypes,
+                    outputTypes,
+                };
+                inputTypes?.forEach((type) => requiredTypes.add(type));
+                outputTypes?.forEach((type) => requiredTypes.add(type));
+            }
+        }
+    }
+    let routesStr = 'export type ChannelsMap = {\n';
+    for (const [channelPath, { routes, message }] of Object.entries(channelsObject)) {
+        routesStr += `  readonly '${channelPath}': {\n`;
+        // Add `routes` object
+        routesStr += `    readonly routes: {\n`;
+        for (const [key, methods] of Object.entries(routes)) {
+            routesStr += `      readonly ${key}: {\n`;
+            for (const [method, handler] of Object.entries(methods)) {
+                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
+            }
+            routesStr += '      },\n';
+        }
+        routesStr += '    },\n';
+        // Add `defaultMessage` outside `routes`
+        if (message) {
+            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
+        }
+        routesStr += '  },\n';
+    }
+    routesStr += '};';
+    return { channels: routesStr, requiredTypes };
+}
+// Utility to format type arrays
+function formatTypeArray(types) {
+    return types ? types.join(' | ') : 'null';
+}

package/dist/src/events/channels/serialize-websocket-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeWebsocketWrapper: (channelsMapPath: string) => string;

package/{src/channels/serialize-websocket-wrapper.ts → dist/src/events/channels/serialize-websocket-wrapper.js}

@@ -1,5 +1,5 @@
-export const serializeWebsocketWrapper = (channelsMapPath: string) => {
-  return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
+export const serializeWebsocketWrapper = (channelsMapPath) => {
+    return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
 import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
 
 class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
@@ -57,5 +57,5 @@ export class PikkuWebSocket<Channel extends keyof ChannelsMap> extends CorePikku
         super.send(data)
     }
 }
-  `
-}
+  `;
+};

package/dist/src/events/http/serialize-fetch-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeFetchWrapper: (routesMapPath: string) => string;

package/{src/http/serialize-fetch-wrapper.ts → dist/src/events/http/serialize-fetch-wrapper.js}

@@ -1,5 +1,5 @@
-export const serializeFetchWrapper = (routesMapPath: string) => {
-  return `
+export const serializeFetchWrapper = (routesMapPath) => {
+    return `
 import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
 import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
 
@@ -63,5 +63,5 @@ export class PikkuFetch extends CorePikkuFetch {
 }
 
 export const pikkuFetch = new PikkuFetch();
-`
-}
+`;
+};

package/dist/src/events/http/serialize-route-imports.d.ts

@@ -0,0 +1 @@
+export declare const serializeRoutes: (outputPath: string, filesWithRoutes: Set<string>, packageMappings?: Record<string, string>) => string;

package/dist/src/events/http/serialize-route-imports.js

@@ -0,0 +1,13 @@
+import { getFileImportRelativePath } from '../utils.js';
+export const serializeRoutes = (outputPath, filesWithRoutes, packageMappings = {}) => {
+    const serializedOutput = [
+        '/* The files with an addRoute function call */',
+    ];
+    Array.from(filesWithRoutes)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};

package/dist/src/events/http/serialize-route-meta.d.ts

@@ -0,0 +1,2 @@
+import type { HTTPRoutesMeta } from '@pikku/core/http';
+export declare const serializeHTTPRoutesMeta: (routesMeta: HTTPRoutesMeta) => string;

package/dist/src/events/http/serialize-route-meta.js

@@ -0,0 +1,6 @@
+export const serializeHTTPRoutesMeta = (routesMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('http', 'meta', ${JSON.stringify(routesMeta, null, 2)})`);
+    return serializedOutput.join('\n');
+};

package/dist/src/events/http/serialize-typed-route-map.d.ts

@@ -0,0 +1,4 @@
+import { HTTPRoutesMeta } from '@pikku/core/http';
+import { MetaInputTypes, TypesMap } from '@pikku/inspector';
+export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
+export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/events/http/serialize-typed-route-map.js

@@ -0,0 +1,107 @@
+import { serializeImportMap } from '../core/serialize-import-map.js';
+export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
+    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for typescript to be aware of routes and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+${serializedMetaTypes}
+
+interface RouteHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedRoutes}
+
+export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
+    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
+        ? RouteHandler<I, O>
+        : never;
+
+export type RoutesWithMethod<Method extends string> = {
+  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
+}[keyof RoutesMap];
+  `;
+};
+export function generateCustomTypes(typesMap, requiredTypes) {
+    return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+        .map(([name, { type, references }]) => {
+        references.forEach((name) => {
+            const originalName = typesMap.getTypeMeta(name).originalName;
+            requiredTypes.add(originalName);
+        });
+        return `export type ${name} = ${type}`;
+    })
+        .join('\n')}`;
+}
+function generateRoutes(routesMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect routes
+    const routesObj = {};
+    for (const meta of routesMeta) {
+        const { route, method, input, output } = meta;
+        // Initialize the route entry if it doesn't exist
+        if (!routesObj[route]) {
+            routesObj[route] = {};
+        }
+        // Store the input and output types separately for RouteHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add method entry
+        routesObj[route][method] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the routes object as a string
+    let routesStr = 'export type RoutesMap = {\n';
+    for (const [routePath, methods] of Object.entries(routesObj)) {
+        routesStr += `  readonly '${routePath}': {\n`;
+        for (const [method, handler] of Object.entries(methods)) {
+            routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+        }
+        routesStr += '  },\n';
+    }
+    routesStr += '};';
+    return routesStr;
+}
+const generateMetaTypes = (metaTypes, typesMap) => {
+    const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
+        const { uniqueName } = typesMap.getTypeMeta(_name);
+        const queryType = query && query.length > 0
+            ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
+            : undefined;
+        if (queryType) {
+            result.set(`${uniqueName}Query`, queryType);
+        }
+        const paramsType = params && params.length > 0
+            ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
+            : undefined;
+        if (paramsType) {
+            result.set(`${uniqueName}Params`, paramsType);
+        }
+        const bodyType = (body && body.length > 0) || (params && params.length > 0)
+            ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
+            : uniqueName;
+        if (bodyType) {
+            result.set(`${uniqueName}Body`, bodyType);
+        }
+        return result;
+    }, new Map());
+    return `
+// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
+${Array.from(nameToTypeMap.entries())
+        .map(([name, type]) => `export type ${name} = ${type} & {}`)
+        .join('\n')}`;
+};

package/dist/src/events/scheduler/serialize-schedulers.d.ts

@@ -0,0 +1,3 @@
+import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+export declare const serializeSchedulers: (outputPath: string, filesWithScheduledTasks: Set<string>, packageMappings?: Record<string, string>) => string;
+export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => string;

package/dist/src/events/scheduler/serialize-schedulers.js

@@ -0,0 +1,23 @@
+import { getFileImportRelativePath } from '../../utils.js';
+export const serializeSchedulers = (outputPath, filesWithScheduledTasks, packageMappings = {}) => {
+    const serializedOutput = [
+        '/* The files with an addSerializedTasks function call */',
+    ];
+    Array.from(filesWithScheduledTasks)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};
+export const serializeSchedulerMeta = (scheduledTasksMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
+    const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
+    if (scheduledTasksMetaValues.length > 0) {
+        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};

package/dist/src/http/serialize-typed-route-map.js

@@ -3,8 +3,8 @@ export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMa
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */

package/dist/src/inspector-glob.d.ts

@@ -1,2 +1,2 @@
 import { InspectorFilters, InspectorState } from '@pikku/inspector';
-export declare const inspectorGlob: (rootDir: string, routeDirectories: string[], filters: InspectorFilters) => Promise<InspectorState>;
+export declare const inspectorGlob: (rootDir: string, srcDirectories: string[], filters: InspectorFilters) => Promise<InspectorState>;

package/dist/src/inspector-glob.js

@@ -2,10 +2,10 @@ import * as path from 'path';
 import { glob } from 'tinyglobby';
 import { inspect } from '@pikku/inspector';
 import { logCommandInfoAndTime } from './utils.js';
-export const inspectorGlob = async (rootDir, routeDirectories, filters) => {
+export const inspectorGlob = async (rootDir, srcDirectories, filters) => {
     let result;
     await logCommandInfoAndTime('Inspecting codebase', 'Inspected codebase', [false], async () => {
-        const routeFiles = (await Promise.all(routeDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
+        const routeFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
         result = await inspect(routeFiles, filters);
     });
     return result;

package/dist/src/openapi-spec-generator.d.ts

@@ -0,0 +1,79 @@
+import { HTTPRoutesMeta } from '@pikku/core';
+interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    paths: Record<string, any>;
+    components: {
+        schemas: Record<string, any>;
+        responses?: Record<string, any>;
+        parameters?: Record<string, any>;
+        examples?: Record<string, any>;
+        requestBodies?: Record<string, any>;
+        headers?: Record<string, any>;
+        securitySchemes?: Record<string, any>;
+    };
+    security?: {
+        [key: string]: any[];
+    }[];
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+}
+export interface OpenAPISpecInfo {
+    info: {
+        title: string;
+        version: string;
+        description: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+    securitySchemes?: Record<string, any>;
+    security?: {
+        [key: string]: any[];
+    }[];
+}
+export declare function generateOpenAPISpec(routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export {};