windmill-utils-internal 1.0.0

package/dist/gen/types.gen.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file is auto-generated by @hey-api/openapi-ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Main entry point for windmill-utils-internal package
+ *
+ * This module provides utilities for handling Windmill flows, scripts, and schemas:
+ * - Inline script extraction and replacement
+ * - Path utilities for different programming languages
+ * - Schema parsing and conversion utilities
+ * - Cross-platform path constants
+ */
+export * from "./inline-scripts";
+export * from "./path-utils";
+export * from "./parse";
+export { SEP, DELIMITER } from "./constants";

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @fileoverview Main entry point for windmill-utils-internal package
+ *
+ * This module provides utilities for handling Windmill flows, scripts, and schemas:
+ * - Inline script extraction and replacement
+ * - Path utilities for different programming languages
+ * - Schema parsing and conversion utilities
+ * - Cross-platform path constants
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELIMITER = exports.SEP = void 0;
+__exportStar(require("./inline-scripts"), exports);
+__exportStar(require("./path-utils"), exports);
+__exportStar(require("./parse"), exports);
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "SEP", { enumerable: true, get: function () { return constants_1.SEP; } });
+Object.defineProperty(exports, "DELIMITER", { enumerable: true, get: function () { return constants_1.DELIMITER; } });

package/dist/inline-scripts/extractor.d.ts

@@ -0,0 +1,30 @@
+import { FlowModule } from "../gen/types.gen";
+/**
+ * Represents an inline script extracted from a flow module
+ */
+interface InlineScript {
+    /** File path where the script content should be written */
+    path: string;
+    /** The actual script content */
+    content: string;
+}
+/**
+ * Extracts inline scripts from flow modules, converting them to separate files
+ * and replacing the original content with file references.
+ *
+ * @param modules - Array of flow modules to process
+ * @param mapping - Optional mapping of module IDs to custom file paths
+ * @param defaultTs - Default TypeScript runtime to use ("bun" or "deno")
+ * @returns Array of inline scripts with their paths and content
+ */
+export declare function extractInlineScripts(modules: FlowModule[], mapping?: Record<string, string>, separator?: string, defaultTs?: "bun" | "deno"): InlineScript[];
+/**
+ * Extracts the current mapping of module IDs to file paths from flow modules
+ * by analyzing existing inline script references.
+ *
+ * @param modules - Array of flow modules to analyze (can be undefined)
+ * @param mapping - Existing mapping to extend (defaults to empty object)
+ * @returns Record mapping module IDs to their corresponding file paths
+ */
+export declare function extractCurrentMapping(modules: FlowModule[] | undefined, mapping?: Record<string, string>): Record<string, string>;
+export {};

package/dist/inline-scripts/extractor.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractInlineScripts = extractInlineScripts;
+exports.extractCurrentMapping = extractCurrentMapping;
+const path_assigner_1 = require("../path-utils/path-assigner");
+/**
+ * Extracts inline scripts from flow modules, converting them to separate files
+ * and replacing the original content with file references.
+ *
+ * @param modules - Array of flow modules to process
+ * @param mapping - Optional mapping of module IDs to custom file paths
+ * @param defaultTs - Default TypeScript runtime to use ("bun" or "deno")
+ * @returns Array of inline scripts with their paths and content
+ */
+function extractInlineScripts(modules, mapping = {}, separator = "/", defaultTs) {
+    return modules.flatMap((m) => {
+        if (m.value.type == "rawscript") {
+            const [basePath, ext] = (0, path_assigner_1.assignPath)(m.id, m.value.language, defaultTs);
+            const path = mapping[m.id] ?? basePath + ext;
+            const content = m.value.content;
+            const r = [{ path: path, content: content }];
+            m.value.content = "!inline " + path.replaceAll(separator, "/");
+            const lock = m.value.lock;
+            if (lock && lock != "") {
+                const lockPath = basePath + "lock";
+                m.value.lock = "!inline " + lockPath.replaceAll(separator, "/");
+                r.push({ path: lockPath, content: lock });
+            }
+            return r;
+        }
+        else if (m.value.type == "forloopflow") {
+            return extractInlineScripts(m.value.modules, mapping, separator, defaultTs);
+        }
+        else if (m.value.type == "branchall") {
+            return m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs));
+        }
+        else if (m.value.type == "whileloopflow") {
+            return extractInlineScripts(m.value.modules, mapping, separator, defaultTs);
+        }
+        else if (m.value.type == "branchone") {
+            return [
+                ...m.value.branches.flatMap((b) => extractInlineScripts(b.modules, mapping, separator, defaultTs)),
+                ...extractInlineScripts(m.value.default, mapping, separator, defaultTs),
+            ];
+        }
+        else {
+            return [];
+        }
+    });
+}
+/**
+ * Extracts the current mapping of module IDs to file paths from flow modules
+ * by analyzing existing inline script references.
+ *
+ * @param modules - Array of flow modules to analyze (can be undefined)
+ * @param mapping - Existing mapping to extend (defaults to empty object)
+ * @returns Record mapping module IDs to their corresponding file paths
+ */
+function extractCurrentMapping(modules, mapping = {}) {
+    if (!modules || !Array.isArray(modules)) {
+        return mapping;
+    }
+    modules.forEach((m) => {
+        if (!m?.value?.type) {
+            return;
+        }
+        if (m.value.type === "rawscript") {
+            if (m.value.content && m.value.content.startsWith("!inline ")) {
+                mapping[m.id] = m.value.content.trim().split(" ")[1];
+            }
+        }
+        else if (m.value.type === "forloopflow" ||
+            m.value.type === "whileloopflow") {
+            extractCurrentMapping(m.value.modules, mapping);
+        }
+        else if (m.value.type === "branchall") {
+            m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
+        }
+        else if (m.value.type === "branchone") {
+            m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
+            extractCurrentMapping(m.value.default, mapping);
+        }
+    });
+    return mapping;
+}

package/dist/inline-scripts/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./replacer";
+export * from "./extractor";

package/dist/inline-scripts/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./replacer"), exports);
+__exportStar(require("./extractor"), exports);

package/dist/inline-scripts/replacer.d.ts

@@ -0,0 +1,16 @@
+import { FlowModule } from "../gen/types.gen";
+/**
+ * Replaces inline script references with actual file content from the filesystem.
+ * This function recursively processes all flow modules and their nested structures.
+ *
+ * @param modules - Array of flow modules to process
+ * @param fileReader - Function to read file content (typically fs.readFile or similar)
+ * @param logger - Optional logger object with info and error methods
+ * @param localPath - Base path for resolving relative file paths
+ * @param removeLocks - Optional array of paths for which to remove lock files
+ * @returns Promise that resolves when all inline scripts have been replaced
+ */
+export declare function replaceInlineScripts(modules: FlowModule[], fileReader: (path: string) => Promise<string>, logger: {
+    info: (message: string) => void;
+    error: (message: string) => void;
+} | undefined, localPath: string, separator?: string, removeLocks?: string[], renamer?: (path: string, newPath: string) => void, deleter?: (path: string) => void): Promise<void>;

package/dist/inline-scripts/replacer.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceInlineScripts = replaceInlineScripts;
+/**
+ * Replaces inline script references with actual file content from the filesystem.
+ * This function recursively processes all flow modules and their nested structures.
+ *
+ * @param modules - Array of flow modules to process
+ * @param fileReader - Function to read file content (typically fs.readFile or similar)
+ * @param logger - Optional logger object with info and error methods
+ * @param localPath - Base path for resolving relative file paths
+ * @param removeLocks - Optional array of paths for which to remove lock files
+ * @returns Promise that resolves when all inline scripts have been replaced
+ */
+async function replaceInlineScripts(modules, fileReader, logger = {
+    info: () => { },
+    error: () => { },
+}, localPath, separator = "/", removeLocks, renamer, deleter) {
+    await Promise.all(modules.map(async (module) => {
+        if (!module.value) {
+            throw new Error(`Module value is undefined for module ${module.id}`);
+        }
+        if (module.value.type === "rawscript" && module.value.content && module.value.content.startsWith("!inline")) {
+            const path = module.value.content.split(" ")[1];
+            const pathPrefix = path.split(".")[0];
+            const pathSuffix = path.split(".").slice(1).join(".");
+            // new path is the module id with the same suffix
+            const newPath = module.id + "." + pathSuffix;
+            try {
+                module.value.content = await fileReader(path);
+            }
+            catch {
+                logger.error(`Script file ${path} not found`);
+                // try new path
+                try {
+                    module.value.content = await fileReader(newPath);
+                }
+                catch {
+                    logger.error(`Script file ${newPath} not found`);
+                }
+            }
+            // rename the file if the prefix is different from the module id (fix old naming)
+            if (pathPrefix != module.id && renamer) {
+                logger.info(`Renaming ${path} to ${module.id}.${pathSuffix}`);
+                try {
+                    renamer(localPath + path, localPath + module.id + "." + pathSuffix);
+                }
+                catch {
+                    logger.info(`Failed to rename ${path} to ${module.id}.${pathSuffix}`);
+                }
+            }
+            const lock = module.value.lock;
+            if (removeLocks && removeLocks.includes(path)) {
+                module.value.lock = undefined;
+                // delete the file if the prefix is different from the module id (fix old naming)
+                if (lock && lock != "") {
+                    const path = lock.split(" ")[1];
+                    const pathPrefix = path.split(".")[0];
+                    if (pathPrefix != module.id && deleter) {
+                        logger.info(`Deleting ${path}`);
+                        try {
+                            deleter(localPath + path);
+                        }
+                        catch {
+                            logger.error(`Failed to delete ${path}`);
+                        }
+                    }
+                }
+            }
+            else if (lock &&
+                typeof lock == "string" &&
+                lock.trimStart().startsWith("!inline ")) {
+                const path = lock.split(" ")[1];
+                try {
+                    module.value.lock = await fileReader(path.replaceAll("/", separator));
+                }
+                catch {
+                    logger.error(`Lock file ${path} not found`);
+                }
+            }
+        }
+        else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
+            await replaceInlineScripts(module.value.modules, fileReader, logger, localPath, separator, removeLocks);
+        }
+        else if (module.value.type === "branchall") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
+            }));
+        }
+        else if (module.value.type === "branchone") {
+            await Promise.all(module.value.branches.map(async (branch) => {
+                await replaceInlineScripts(branch.modules, fileReader, logger, localPath, separator, removeLocks);
+            }));
+            await replaceInlineScripts(module.value.default, fileReader, logger, localPath, separator, removeLocks);
+        }
+    }));
+}

package/dist/parse/index.d.ts

@@ -0,0 +1 @@
+export * from "./parse-schema";

package/dist/parse/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parse-schema"), exports);

package/dist/parse/parse-schema.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Type alias for enum values - can be an array of strings or undefined
+ */
+export type EnumType = string[] | undefined;
+/**
+ * Represents a property in a JSON schema with various validation and display options
+ */
+export interface SchemaProperty {
+    type: string | undefined;
+    description?: string;
+    pattern?: string;
+    default?: any;
+    enum?: EnumType;
+    contentEncoding?: 'base64' | 'binary';
+    format?: string;
+    items?: {
+        type?: 'string' | 'number' | 'bytes' | 'object' | 'resource';
+        contentEncoding?: 'base64';
+        enum?: string[];
+        resourceType?: string;
+        properties?: {
+            [name: string]: SchemaProperty;
+        };
+    };
+    min?: number;
+    max?: number;
+    currency?: string;
+    currencyLocale?: string;
+    multiselect?: boolean;
+    customErrorMessage?: string;
+    properties?: {
+        [name: string]: SchemaProperty;
+    };
+    required?: string[];
+    showExpr?: string;
+    password?: boolean;
+    order?: string[];
+    nullable?: boolean;
+    dateFormat?: string;
+    title?: string;
+    placeholder?: string;
+    oneOf?: SchemaProperty[];
+    originalType?: string;
+}
+/**
+ * Converts argument signature types to JSON schema properties.
+ * This function handles various Windmill-specific types and converts them
+ * to standard JSON schema format while preserving existing property metadata.
+ *
+ * @param t - The argument signature type definition (can be string or complex object types)
+ * @param oldS - Existing schema property to update with new type information
+ */
+export declare function argSigToJsonSchemaType(t: string | {
+    resource: string | null;
+} | {
+    list: (string | {
+        name?: string;
+        props?: {
+            key: string;
+            typ: any;
+        }[];
+    }) | {
+        str: any;
+    } | {
+        object: {
+            name?: string;
+            props?: {
+                key: string;
+                typ: any;
+            }[];
+        };
+    } | null;
+} | {
+    dynselect: string;
+} | {
+    str: string[] | null;
+} | {
+    object: {
+        name?: string;
+        props?: {
+            key: string;
+            typ: any;
+        }[];
+    };
+} | {
+    oneof: {
+        label: string;
+        properties: {
+            key: string;
+            typ: any;
+        }[];
+    }[];
+}, oldS: SchemaProperty): void;

package/dist/parse/parse-schema.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argSigToJsonSchemaType = argSigToJsonSchemaType;
+/**
+ * Converts argument signature types to JSON schema properties.
+ * This function handles various Windmill-specific types and converts them
+ * to standard JSON schema format while preserving existing property metadata.
+ *
+ * @param t - The argument signature type definition (can be string or complex object types)
+ * @param oldS - Existing schema property to update with new type information
+ */
+function argSigToJsonSchemaType(t, oldS) {
+    const newS = { type: '' };
+    if (t === 'int') {
+        newS.type = 'integer';
+    }
+    else if (t === 'float') {
+        newS.type = 'number';
+    }
+    else if (t === 'bool') {
+        newS.type = 'boolean';
+    }
+    else if (t === 'email') {
+        newS.type = 'string';
+        newS.format = 'email';
+    }
+    else if (t === 'sql') {
+        newS.type = 'string';
+        newS.format = 'sql';
+    }
+    else if (t === 'yaml') {
+        newS.type = 'string';
+        newS.format = 'yaml';
+    }
+    else if (t === 'bytes') {
+        newS.type = 'string';
+        newS.contentEncoding = 'base64';
+        newS.originalType = 'bytes';
+    }
+    else if (t === 'datetime') {
+        newS.type = 'string';
+        newS.format = 'date-time';
+    }
+    else if (typeof t !== 'string' && 'oneof' in t) {
+        newS.type = 'object';
+        if (t.oneof) {
+            newS.oneOf = t.oneof.map((obj) => {
+                const oldObjS = oldS.oneOf?.find((o) => o?.title === obj.label) ?? undefined;
+                const properties = {};
+                for (const prop of obj.properties) {
+                    if (oldObjS?.properties && prop.key in oldObjS?.properties) {
+                        properties[prop.key] = oldObjS?.properties[prop.key];
+                    }
+                    else {
+                        properties[prop.key] = { description: '', type: '' };
+                    }
+                    argSigToJsonSchemaType(prop.typ, properties[prop.key]);
+                }
+                return {
+                    type: 'object',
+                    title: obj.label,
+                    properties,
+                    order: oldObjS?.order ?? undefined
+                };
+            });
+        }
+    }
+    else if (typeof t !== 'string' && `object` in t) {
+        newS.type = 'object';
+        if (t.object.name) {
+            newS.format = `resource-${t.object.name}`;
+        }
+        if (t.object.props) {
+            const properties = {};
+            for (const prop of t.object.props) {
+                if (oldS.properties && prop.key in oldS.properties) {
+                    properties[prop.key] = oldS.properties[prop.key];
+                }
+                else {
+                    properties[prop.key] = { description: '', type: '' };
+                }
+                argSigToJsonSchemaType(prop.typ, properties[prop.key]);
+            }
+            newS.properties = properties;
+        }
+    }
+    else if (typeof t !== 'string' && `str` in t) {
+        newS.type = 'string';
+        if (t.str) {
+            newS.originalType = 'enum';
+            newS.enum = t.str;
+        }
+        else if (oldS.originalType == 'string' && oldS.enum) {
+            newS.originalType = 'string';
+            newS.enum = oldS.enum;
+        }
+        else {
+            newS.originalType = 'string';
+            newS.enum = undefined;
+        }
+    }
+    else if (typeof t !== 'string' && `resource` in t) {
+        newS.type = 'object';
+        newS.format = `resource-${t.resource}`;
+    }
+    else if (typeof t !== 'string' && `dynselect` in t) {
+        newS.type = 'object';
+        newS.format = `dynselect-${t.dynselect}`;
+    }
+    else if (typeof t !== 'string' && `list` in t) {
+        newS.type = 'array';
+        if (t.list === 'int' || t.list === 'float') {
+            newS.items = { type: 'number' };
+            newS.originalType = 'number[]';
+        }
+        else if (t.list === 'bytes') {
+            newS.items = { type: 'string', contentEncoding: 'base64' };
+            newS.originalType = 'bytes[]';
+        }
+        else if (t.list && typeof t.list == 'object' && 'str' in t.list && t.list.str) {
+            newS.items = { type: 'string', enum: t.list.str };
+            newS.originalType = 'enum[]';
+        }
+        else if (t.list == 'string' || (t.list && typeof t.list == 'object' && 'str' in t.list)) {
+            newS.items = { type: 'string', enum: oldS.items?.enum };
+            newS.originalType = 'string[]';
+        }
+        else if (t.list && typeof t.list == 'object' && 'resource' in t.list && t.list.resource) {
+            newS.items = {
+                type: 'resource',
+                resourceType: t.list.resource
+            };
+            newS.originalType = 'resource[]';
+        }
+        else if (t.list && typeof t.list == 'object' && 'object' in t.list && t.list.object) {
+            if (t.list.object.name) {
+                newS.format = `resource-${t.list.object.name}`;
+            }
+            if (t.list.object.props && t.list.object.props.length > 0) {
+                const properties = {};
+                for (const prop of t.list.object.props) {
+                    properties[prop.key] = { description: '', type: '' };
+                    argSigToJsonSchemaType(prop.typ, properties[prop.key]);
+                }
+                newS.items = { type: 'object', properties: properties };
+            }
+            else {
+                newS.items = { type: 'object' };
+            }
+            newS.originalType = 'record[]';
+        }
+        else {
+            newS.items = { type: 'object' };
+            newS.originalType = 'object[]';
+        }
+    }
+    else {
+        newS.type = 'object';
+    }
+    const preservedFields = [
+        'description',
+        'pattern',
+        'min',
+        'max',
+        'currency',
+        'currencyLocale',
+        'multiselect',
+        'customErrorMessage',
+        'required',
+        'showExpr',
+        'password',
+        'order',
+        'dateFormat',
+        'title',
+        'placeholder'
+    ];
+    preservedFields.forEach((field) => {
+        // @ts-ignore
+        if (oldS[field] !== undefined) {
+            // @ts-ignore
+            newS[field] = oldS[field];
+        }
+    });
+    if (oldS.type != newS.type) {
+        for (const prop of Object.getOwnPropertyNames(newS)) {
+            if (prop != 'description') {
+                // @ts-ignore
+                delete oldS[prop];
+            }
+        }
+    }
+    else if ((oldS.format == 'date' || oldS.format === 'date-time') && newS.format == 'string') {
+        newS.format = oldS.format;
+    }
+    else if (newS.format == 'date-time' && oldS.format == 'date') {
+        newS.format = 'date';
+    }
+    else if (oldS.items?.type != newS.items?.type) {
+        delete oldS.items;
+    }
+    if (oldS.format && !newS.format) {
+        oldS.format = undefined;
+    }
+    Object.assign(oldS, newS);
+}

package/dist/path-utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./path-assigner";

package/dist/path-utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./path-assigner"), exports);

package/dist/path-utils/path-assigner.d.ts

@@ -0,0 +1,28 @@
+import { RawScript } from "../gen/types.gen";
+/**
+ * Union type of all supported programming languages in Windmill
+ */
+export type SupportedLanguage = RawScript["language"] | "frontend" | "bunnative" | "oracledb" | "rust" | "csharp" | "nu" | "ansible" | "java" | "duckdb";
+/**
+ * Mapping of supported languages to their file extensions
+ */
+export declare const LANGUAGE_EXTENSIONS: Record<SupportedLanguage, string>;
+/**
+ * Gets the appropriate file extension for a given programming language.
+ * Handles special cases for TypeScript variants based on the default runtime.
+ *
+ * @param language - The programming language to get extension for
+ * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
+ * @returns File extension string (without the dot)
+ */
+export declare function getLanguageExtension(language: SupportedLanguage, defaultTs?: "bun" | "deno"): string;
+/**
+ * Assigns a file path for an inline script based on its ID and language.
+ * Returns both the base path and extension as separate components.
+ *
+ * @param id - Unique identifier for the script
+ * @param language - Programming language of the script
+ * @param defaultTs - Default TypeScript runtime ("bun" or "deno")
+ * @returns Tuple containing [basePath, extension]
+ */
+export declare function assignPath(id: string, language: SupportedLanguage, defaultTs?: "bun" | "deno"): [string, string];