@pikku/cli 0.6.6

package/dist/src/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/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/http/serialize-route-meta.js

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

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

@@ -0,0 +1,3 @@
+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;

package/dist/src/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 serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedRoutes = generateRoutes(routesMeta, 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];
+  `;
+};
+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/inspector-glob.d.ts

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

package/dist/src/inspector-glob.js

@@ -0,0 +1,12 @@
+import * as path from 'path';
+import { glob } from 'glob';
+import { inspect } from '@pikku/inspector';
+import { logCommandInfoAndTime } from './utils.js';
+export const inspectorGlob = async (rootDir, routeDirectories) => {
+    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();
+        result = await inspect(routeFiles);
+    });
+    return result;
+};

package/dist/src/nextjs/serialize-nextjs-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeNextJsWrapper: (routesPath: string, routesMapPath: string, schemasPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;

package/dist/src/nextjs/serialize-nextjs-wrapper.js

@@ -0,0 +1,149 @@
+export const serializeNextJsWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
+    return `'server-only'
+
+/**
+ * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
+ * This ensures type safety for route handling methods when integrating with the \`@pikku/core\` framework.
+ */
+import { PikkuNextJS } from '@pikku/next'
+import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+
+${configImport}
+${singleServicesFactoryImport}
+${sessionServicesImport}
+
+import '${routesPath}'
+import '${schemasPath}'
+
+let _pikku: PikkuNextJS | undefined
+
+/**
+ * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
+ *
+ * @returns An object containing methods for making dynamic and static action requests.
+ */
+export const pikku = () => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJS(
+      createConfig as any,
+      createSingletonServices as any,
+      createSessionServices
+    )
+  }
+
+  /**
+   * Makes a dynamic action request for a specified route and method.
+   * Dynamic requests may access headers and cookies, making them unsuitable for precompile stages.
+   *
+   * @template Route - The route key from the RoutesMap.
+   * @template Method - The method key from the specified route.
+   * @param route - The route to make the request to.
+   * @param method - The method to be used for the request.
+   * @param data - The input data for the request, defaults to null.
+   * @returns A promise that resolves to the output of the route handler.
+   */
+  const dynamicActionRequest = async <
+    Route extends keyof RoutesMap,
+    Method extends keyof RoutesMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: RouteHandlerOf<Route, Method>['input'] = null
+  ): Promise<RouteHandlerOf<Route, Method>['output']> => {
+    return _pikku!.actionRequest(route, method, data as any)
+  }
+
+  /**
+   * Makes a static action request for a specified route and method.
+   * Static requests do not depend on headers or cookies and are suitable for precompile stages.
+   *
+   * @template Route - The route key from the RoutesMap.
+   * @template Method - The method key from the specified route.
+   * @param route - The route to make the request to.
+   * @param method - The method to be used for the request.
+   * @param data - The input data for the request, defaults to null.
+   * @returns A promise that resolves to the output of the route handler.
+   */
+  const staticActionRequest = async <
+    Route extends keyof RoutesMap,
+    Method extends keyof RoutesMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: RouteHandlerOf<Route, Method>['input'] = null
+  ): Promise<RouteHandlerOf<Route, Method>['output']> => {
+    return _pikku!.staticActionRequest(route, method, data as any)
+  }
+
+  /**
+   * Makes a dynamic POST request for a specified route.
+   */
+  const dynamicPost = <Route extends RoutesWithMethod<'POST'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    return dynamicActionRequest(route, 'POST', data)
+  }
+
+  /**
+   * Makes a dynamic GET request for a specified route.
+   */
+  const dynamicGet = <Route extends RoutesWithMethod<'GET'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    return dynamicActionRequest(route, 'GET', data)
+  }
+
+  /**
+   * Makes a dynamic PATCH request for a specified route.
+   */
+  const dynamicPatch = <Route extends RoutesWithMethod<'PATCH'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'PATCH'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> => {
+    return dynamicActionRequest(route, 'PATCH', data)
+  }
+
+  /**
+   * Makes a dynamic DELETE request for a specified route.
+   */
+  const dynamicDel = <Route extends RoutesWithMethod<'DELETE'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'DELETE'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> => {
+    return dynamicActionRequest(route, 'DELETE', data)
+  }
+
+  // Static
+
+  /**
+   * Makes a static POST request for a specified route.
+   */
+  const staticPost = <Route extends RoutesWithMethod<'POST'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    return staticActionRequest(route, 'POST', data)
+  }
+
+  /**
+   * Makes a static GET request for a specified route.
+   */
+  const staticGet = <Route extends RoutesWithMethod<'GET'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    return staticActionRequest(route, 'GET', data)
+  }
+
+  return {
+    get: dynamicGet,
+    post: dynamicPost,
+    patch: dynamicPatch,
+    del: dynamicDel,
+    staticGet,
+    staticPost
+  }
+}`;
+};

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

@@ -0,0 +1,79 @@
+import { HTTPRoutesMeta } from '@pikku/core/http';
+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 {};

package/dist/src/openapi/openapi-spec-generator.js

@@ -0,0 +1,135 @@
+import { getErrors } from '@pikku/core/errors';
+import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
+const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
+const getErrorResponseForConstructorName = (constructorName) => {
+    const foundError = Array.from(getErrors().entries()).find(([e]) => e.name === constructorName);
+    if (foundError) {
+        return foundError[1];
+    }
+    return undefined;
+};
+const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
+    const requiredSchemas = new Set(routesMeta
+        .map(({ inputTypes, output }) => [inputTypes?.body, output])
+        .flat()
+        .filter((schema) => !!schema));
+    const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
+        if (requiredSchemas.has(key)) {
+            const convertedSchema = await convertSchema(schema, {
+                convertUnreferencedDefinitions: false,
+                dereference: { circular: 'ignore' },
+            });
+            return [key, convertedSchema];
+        }
+        return;
+    }));
+    return Object.fromEntries(convertedEntries.filter((s) => !!s));
+};
+export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
+    const paths = {};
+    routeMeta.forEach((meta) => {
+        const { route, method, inputTypes, output, params, query, docs } = meta;
+        const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
+        if (!paths[path]) {
+            paths[path] = {};
+        }
+        const responses = {};
+        docs?.errors?.forEach((error) => {
+            const errorResponse = getErrorResponseForConstructorName(error);
+            if (errorResponse) {
+                responses[errorResponse.status] = {
+                    description: errorResponse.message,
+                };
+            }
+        });
+        const operation = {
+            description: docs?.description ||
+                `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+            tags: docs?.tags || [route.split('/')[1] || 'default'],
+            parameters: [],
+            responses: {
+                ...responses,
+                '200': {
+                    description: 'Successful response',
+                    content: output
+                        ? {
+                            'application/json': {
+                                schema: typeof output === 'string' &&
+                                    ['boolean', 'string', 'number'].includes(output)
+                                    ? { type: output }
+                                    : { $ref: `#/components/schemas/${output}` },
+                            },
+                        }
+                        : undefined,
+                },
+            },
+        };
+        const bodyType = inputTypes?.body;
+        if (bodyType) {
+            operation.requestBody = {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: typeof bodyType === 'string' &&
+                            ['boolean', 'string', 'number'].includes(bodyType)
+                            ? { type: bodyType }
+                            : { $ref: `#/components/schemas/${bodyType}` },
+                    },
+                },
+            };
+        }
+        if (params) {
+            operation.parameters = params.map((param) => ({
+                name: param,
+                in: 'path',
+                required: true,
+                schema: { type: 'string' },
+            }));
+        }
+        if (query) {
+            operation.parameters.push(...query.map((query) => ({
+                name: query,
+                in: 'query',
+                required: false,
+                schema: { type: 'string' },
+            })));
+        }
+        paths[path][method] = operation;
+    });
+    return {
+        openapi: '3.1.0',
+        info: additionalInfo.info,
+        servers: additionalInfo.servers,
+        paths,
+        components: {
+            schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+            responses: {},
+            parameters: {},
+            examples: {},
+            requestBodies: {},
+            headers: {},
+            securitySchemes: additionalInfo.securitySchemes || {
+                ApiKeyAuth: {
+                    type: 'apiKey',
+                    in: 'header',
+                    name: 'x-api-key',
+                },
+                BearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                },
+            },
+        },
+        security: additionalInfo.security || [
+            {
+                ApiKeyAuth: [],
+            },
+            {
+                BearerAuth: [],
+            },
+        ],
+        tags: additionalInfo.tags,
+        externalDocs: additionalInfo.externalDocs,
+        // definitions
+    };
+}

package/dist/src/pikku-cli-config.d.ts

@@ -0,0 +1,31 @@
+import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js';
+export interface PikkuCLICoreOutputFiles {
+    outDir?: string;
+    routesFile: string;
+    channelsFile: string;
+    schedulersFile: string;
+    schemaDirectory: string;
+    typesDeclarationFile: string;
+    routesMapDeclarationFile: string;
+    channelsMapDeclarationFile: string;
+    bootstrapFile: string;
+}
+export type PikkuCLIConfig = {
+    $schema?: string;
+    extends?: string;
+    rootDir: string;
+    routeDirectories: string[];
+    packageMappings: Record<string, string>;
+    supportsImportAttributes: boolean;
+    configDir: string;
+    tsconfig: string;
+    nextJSfile?: string;
+    fetchFile?: string;
+    websocketFile?: string;
+    openAPI?: {
+        outputFile: string;
+        additionalInfo: OpenAPISpecInfo;
+    };
+} & PikkuCLICoreOutputFiles;
+export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, exitProcess?: boolean) => Promise<PikkuCLIConfig>;
+export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

package/dist/src/pikku-cli-config.js

@@ -0,0 +1,113 @@
+import { join, dirname, resolve, isAbsolute } from 'path';
+import { readdir, readFile } from 'fs/promises';
+const CONFIG_DIR_FILES = ['nextJSfile', 'fetchFile', 'websocketFile'];
+export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitProcess = false) => {
+    const config = await _getPikkuCLIConfig(configFile, requiredFields, exitProcess);
+    return config;
+};
+const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitProcess = false) => {
+    if (!configFile) {
+        let execDirectory = process.cwd();
+        const files = await readdir(execDirectory);
+        const file = files.find((file) => /pikku\.config\.(ts|js|json)$/.test(file));
+        if (!file) {
+            const errorMessage = '\nConfig file pikku.config.json not found\nExiting...';
+            if (exitProcess) {
+                console.error(errorMessage);
+                process.exit(1);
+            }
+            throw new Error(errorMessage);
+        }
+        configFile = join(execDirectory, file);
+    }
+    try {
+        let result;
+        const file = await readFile(configFile, 'utf-8');
+        const configDir = dirname(configFile);
+        const config = JSON.parse(file);
+        if (config.extends) {
+            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], exitProcess);
+            result = {
+                ...extendedConfig,
+                ...config,
+                configDir,
+                packageMappings: {
+                    ...extendedConfig.packageMappings,
+                    ...config.packageMappings,
+                },
+            };
+        }
+        else {
+            result = {
+                ...config,
+                configDir,
+                packageMappings: config.packageMappings || {},
+                rootDir: config.rootDir
+                    ? resolve(configDir, config.rootDir)
+                    : configDir,
+            };
+        }
+        if (result.outDir) {
+            if (!result.schemaDirectory) {
+                result.schemaDirectory = join(result.outDir, 'pikku-schemas');
+            }
+            if (!result.routesFile) {
+                result.routesFile = join(result.outDir, 'pikku-routes.gen.ts');
+            }
+            if (!result.schedulersFile) {
+                result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts');
+            }
+            if (!result.channelsFile) {
+                result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts');
+            }
+            if (!result.typesDeclarationFile) {
+                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.d.ts');
+            }
+            if (!result.routesMapDeclarationFile) {
+                result.routesMapDeclarationFile = join(result.outDir, 'pikku-routes-map.gen.d.ts');
+            }
+            if (!result.channelsMapDeclarationFile) {
+                result.channelsMapDeclarationFile = join(result.outDir, 'pikku-channels-map.gen.d.ts');
+            }
+            if (!result.bootstrapFile) {
+                result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
+            }
+        }
+        if (requiredFields.length > 0) {
+            validateCLIConfig(result, requiredFields);
+        }
+        for (const objectKey of Object.keys(result)) {
+            if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
+                const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
+                    ? result.configDir
+                    : result.rootDir;
+                if (result[objectKey]) {
+                    if (!isAbsolute(result[objectKey])) {
+                        result[objectKey] = join(relativeTo, result[objectKey]);
+                    }
+                }
+            }
+        }
+        if (!isAbsolute(result.tsconfig)) {
+            result.tsconfig = join(result.rootDir, result.tsconfig);
+        }
+        return result;
+    }
+    catch (e) {
+        console.error(e);
+        console.error(`Config file not found: ${configFile}`);
+        process.exit(1);
+    }
+};
+export const validateCLIConfig = (cliConfig, required) => {
+    let errors = [];
+    for (const key of required) {
+        if (!cliConfig[key]) {
+            errors.push(key);
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`);
+        process.exit(1);
+    }
+};

package/dist/src/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;