@itzworking/devkit 0.0.198-canary.20250707-e7f7621

package/README.md

@@ -0,0 +1,15 @@
+# ITz Working (AWS Serverless, TypeScript)
+
+> **ITz Working because you built it!**
+
+Framework for building AWS Serverless applications with TypeScript.
+
+- [Intro](#intro)
+- [Key features](#key-features)
+- [Usage](#usage)
+
+## Intro
+
+## Key features
+
+## Usage

package/dist-cjs/generate-api-clients/api-type-spec-utils.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTypeDefinition = exports.setTypeKind = void 0;
+const ts_morph_1 = require("ts-morph");
+function isDecoratedClass(classDecl) {
+    let current = classDecl;
+    while (current) {
+        const base = current.getBaseClass();
+        if (!base)
+            break;
+        if (base.getName() === "DecoratedClass") {
+            return true;
+        }
+        current = base;
+    }
+    return false;
+}
+function isZodSchema(varDecl) {
+    if (!varDecl)
+        return false;
+    const initializer = varDecl.getInitializer();
+    if (!initializer)
+        return false;
+    if (initializer.getKind() === ts_morph_1.SyntaxKind.CallExpression) {
+        const callExpr = initializer.asKind(ts_morph_1.SyntaxKind.CallExpression);
+        if (callExpr) {
+            const expr = callExpr.getExpression();
+            if (expr.getKind() === ts_morph_1.SyntaxKind.PropertyAccessExpression ||
+                expr.getKind() === ts_morph_1.SyntaxKind.Identifier) {
+                const exprText = expr.getText();
+                if (exprText.startsWith("z.")) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+const setTypeKind = (type, sourceFile) => {
+    if (!type)
+        return;
+    let kind = type.kind;
+    const importSourceFile = type.importPath
+        ? sourceFile
+            .getImportDeclarations()
+            .find((d) => d.getModuleSpecifierValue() === type.importPath)
+            ?.getModuleSpecifierSourceFile()
+        : sourceFile;
+    const inputClass = importSourceFile?.getClass(type.typeName);
+    if (isDecoratedClass(inputClass)) {
+        kind = "decorated-class";
+    }
+    else {
+        const inputVar = importSourceFile?.getVariableDeclaration(type.typeName);
+        if (isZodSchema(inputVar)) {
+            kind = "zod-schema";
+        }
+    }
+    type.kind = kind;
+};
+exports.setTypeKind = setTypeKind;
+const extractTypeDefinition = (type, sourceFile) => {
+    if (!type?.importPath) {
+        return;
+    }
+    const importSourceFile = sourceFile
+        .getImportDeclarations()
+        .find((d) => d.getModuleSpecifierValue() === type.importPath)
+        ?.getModuleSpecifierSourceFile();
+    if (!importSourceFile) {
+        throw new Error(`Could not find import source file for path: ${type.importPath}`);
+    }
+    const allowedImportLibraries = [
+        "@itzworking/decorated-class",
+        "zod",
+        "zod/v4",
+    ];
+    const allowedImports = [];
+    const inlinedFiles = [];
+    const filesToProcess = [importSourceFile];
+    const processedFiles = new Set();
+    while (filesToProcess.length > 0) {
+        const currentSourceFile = filesToProcess.pop();
+        if (currentSourceFile === undefined) {
+            console.log("Source file is undefined, skipping...");
+            continue;
+        }
+        const filePath = currentSourceFile.getFilePath();
+        if (processedFiles.has(filePath)) {
+            continue;
+        }
+        processedFiles.add(filePath);
+        for (const importDeclarations of currentSourceFile.getImportDeclarations()) {
+            const moduleSpecifier = importDeclarations
+                .getModuleSpecifier()
+                .getLiteralValue();
+            if (allowedImportLibraries.includes(moduleSpecifier)) {
+                const namespaceImport = importDeclarations
+                    .getNamespaceImport()
+                    ?.getText();
+                if (namespaceImport) {
+                    const currentNamespaceImport = allowedImports.find((i) => i.namespaceImport && i.importPath === moduleSpecifier);
+                    if (!currentNamespaceImport) {
+                        allowedImports.push({
+                            namespaceImport: true,
+                            importPath: moduleSpecifier,
+                            importNames: new Set([namespaceImport]),
+                        });
+                    }
+                    else {
+                        currentNamespaceImport.importNames.add(namespaceImport);
+                    }
+                }
+                else {
+                    let currentImport = allowedImports.find((i) => !i.namespaceImport && i.importPath === moduleSpecifier);
+                    if (!currentImport) {
+                        currentImport = {
+                            namespaceImport: false,
+                            importPath: moduleSpecifier,
+                            importNames: new Set(),
+                        };
+                        allowedImports.push(currentImport);
+                    }
+                    for (const namedImport of importDeclarations.getNamedImports()) {
+                        currentImport.importNames.add(namedImport.getName());
+                    }
+                }
+            }
+            else {
+                const importedSourceFile = importDeclarations.getModuleSpecifierSourceFile();
+                const importedFilePath = importedSourceFile?.getFilePath();
+                if (!importedSourceFile || !importedFilePath) {
+                    continue;
+                }
+                if (!processedFiles.has(importedFilePath)) {
+                    filesToProcess.push(importedSourceFile);
+                }
+            }
+        }
+        let text = currentSourceFile.getFullText();
+        const importDeclarations = currentSourceFile.getImportDeclarations();
+        for (const importDecl of importDeclarations.reverse()) {
+            const start = importDecl.getStart();
+            const end = importDecl.getEnd();
+            text = (text.slice(0, start) + text.slice(end)).trim();
+        }
+        inlinedFiles.push({
+            filePath: filePath,
+            text,
+        });
+    }
+    type.typeDefinition = {
+        allowedImports: allowedImports.map((i) => ({
+            ...i,
+            importNames: Array.from(i.importNames),
+        })),
+        inlinedFiles: inlinedFiles.reverse(),
+    };
+};
+exports.extractTypeDefinition = extractTypeDefinition;

package/dist-cjs/generate-api-clients/copy-api-client.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyApiClient = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const template_loader_1 = require("./template-loader");
+const path = tslib_1.__importStar(require("path"));
+const copyApiClient = (options) => {
+    const apiClientContent = (0, template_loader_1.loadTemplate)("api-client.ts.template");
+    (0, utils_1.writeFile)({
+        filePath: path.join(options.outputDirectory, "api-client.ts"),
+        content: apiClientContent,
+        allowOverwrite: options.allowOverwrite,
+        verbose: options.verbose,
+    });
+};
+exports.copyApiClient = copyApiClient;

package/dist-cjs/generate-api-clients/generate-api-client-class.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApiClientClass = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const template_loader_1 = require("./template-loader");
+const pathWithQuotes = (apiPath) => {
+    return `${apiPath.includes("{") ? "`" : '"'}${apiPath}${apiPath.includes("{") ? "`" : '"'}`.replace(/{/g, "${");
+};
+handlebars_1.default.registerHelper("pathWithQuotes", pathWithQuotes);
+const prepareMethods = (apis) => {
+    const methods = [];
+    for (const api of apis) {
+        const pathParams = (api.fullPath.match(/\{[^}]+}/g) || []).map((p) => p.replace(/[{}]/g, ""));
+        let params = "";
+        if (api.method === "GET") {
+            if (pathParams.length > 0) {
+                params += pathParams.map((p) => `${p}: string`).join(", ");
+            }
+            if (api.inputType) {
+                if (params)
+                    params += ", ";
+                params += `body: ${api.inputType}`;
+            }
+        }
+        else {
+            if (pathParams.length > 0 || api.inputType) {
+                params += "{ ";
+                if (pathParams.length > 0) {
+                    params += pathParams.join(", ") + (api.inputType ? ", " : "");
+                }
+                if (api.inputType) {
+                    params += `body`;
+                }
+                params += " }: { ";
+                if (pathParams.length > 0) {
+                    params +=
+                        pathParams.map((p) => `${p}: string`).join(", ") +
+                            (api.inputType ? ", " : "");
+                }
+                if (api.inputType) {
+                    params += `body: ${api.inputType.typeName}`;
+                }
+                params += " }";
+            }
+        }
+        methods.push({
+            name: (0, utils_1.toPropertyName)(api.actionName),
+            params,
+            returnType: api.outputType ? api.outputType.typeName : "void",
+            method: api.method.toLowerCase(),
+            fullPath: api.fullPath,
+            inputType: api.inputType,
+            outputType: api.outputType,
+        });
+    }
+    return methods;
+};
+const prepareTypeImports = (apis) => {
+    const imports = [];
+    for (const api of apis) {
+        const typeSpecs = [api.inputType, api.outputType];
+        for (const typeSpec of typeSpecs) {
+            if (!typeSpec || !typeSpec.importPath)
+                continue;
+            for (const allowedImport of typeSpec.typeDefinition.allowedImports) {
+                let currentImport = imports.find((i) => i.importPath === allowedImport.importPath);
+                if (!currentImport) {
+                    currentImport = {
+                        importPath: allowedImport.importPath,
+                        importNames: new Set(),
+                    };
+                    imports.push(currentImport);
+                }
+                if (allowedImport.namespaceImport) {
+                    const namespaceNames = allowedImport.importNames;
+                    const conflictingNamespaceNames = [];
+                    if (namespaceNames.length > 1) {
+                        conflictingNamespaceNames.push(...namespaceNames);
+                    }
+                    if (currentImport.namespaceImport &&
+                        currentImport.namespaceImport !== namespaceNames[0]) {
+                        conflictingNamespaceNames.push(currentImport.namespaceImport);
+                        conflictingNamespaceNames.push(...namespaceNames);
+                    }
+                    if (conflictingNamespaceNames.length > 0) {
+                        throw new Error(`Conflicting namespace imports found for module "${allowedImport.importPath}": ` +
+                            `[${conflictingNamespaceNames.join(", ")}]. ` +
+                            `All namespace imports from the same module must use the same name. ` +
+                            `Please consolidate to use a single namespace import: import * as [name] from "${allowedImport.importPath}"`);
+                    }
+                    const namespaceName = namespaceNames[0];
+                    const conflictingImport = imports.find((imp) => imp.importPath !== allowedImport.importPath &&
+                        imp.namespaceImport === namespaceName);
+                    if (conflictingImport) {
+                        throw new Error(`Namespace name "${namespaceName}" is used by imports from: ` +
+                            `"${conflictingImport.importPath}" and "${allowedImport.importPath}". ` +
+                            `Cannot use the same namespace name for different modules. ` +
+                            `Please use a different namespace name for one of the imports.`);
+                    }
+                    currentImport.namespaceImport = namespaceName;
+                }
+                else {
+                    for (const importName of allowedImport.importNames) {
+                        currentImport.importNames.add(importName);
+                    }
+                }
+            }
+        }
+    }
+    return imports.map((i) => ({
+        namespaceImport: i.namespaceImport,
+        importPath: i.importPath,
+        importNames: Array.from(i.importNames).sort(),
+    }));
+};
+const generateApiClientClass = ({ basePath, apis, }, options) => {
+    const className = (0, utils_1.toClassName)(basePath) + "Api";
+    const imports = (0, utils_1.prepareImports)(apis, options);
+    const methods = prepareMethods(apis);
+    const templateSource = (0, template_loader_1.loadTemplate)("api-client.hbs");
+    const template = handlebars_1.default.compile(templateSource);
+    let apiTypesFile = "";
+    if (options.typeResolutionMode === "inline-types") {
+        const typeImports = prepareTypeImports(apis);
+        for (const typeImport of typeImports) {
+            if (typeImport.namespaceImport) {
+                apiTypesFile += `import * as ${typeImport.namespaceImport} from "${typeImport.importPath}";\n`;
+            }
+            if (typeImport.importNames.length > 0) {
+                apiTypesFile += `import { ${typeImport.importNames.join(", ")} } from "${typeImport.importPath}";\n`;
+            }
+        }
+        const inlinedFilePaths = new Set();
+        for (const api of apis) {
+            const typeSpecs = [api.inputType, api.outputType];
+            for (const typeSpec of typeSpecs) {
+                if (!typeSpec || !typeSpec.importPath)
+                    continue;
+                for (const inlinedFile of typeSpec.typeDefinition.inlinedFiles) {
+                    if (inlinedFilePaths.has(inlinedFile.filePath)) {
+                        continue;
+                    }
+                    inlinedFilePaths.add(inlinedFile.filePath);
+                    apiTypesFile += "\n\n";
+                    apiTypesFile += inlinedFile.text;
+                }
+            }
+        }
+    }
+    return {
+        apiClientClassFile: template({
+            className,
+            imports,
+            methods,
+        }),
+        apiTypesFile,
+    };
+};
+exports.generateApiClientClass = generateApiClientClass;

package/dist-cjs/generate-api-clients/generate-api-clients.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApiClients = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const parse_discovered_apis_1 = require("./parse-discovered-apis");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const generate_api_client_class_1 = require("./generate-api-client-class");
+const generate_hook_1 = require("./generate-hook");
+const copy_api_client_1 = require("./copy-api-client");
+const generateApiClients = async (options = {}) => {
+    const { tsConfigPath = "tsconfig.json", targetTypeSystem = "preserve-backend", typeResolutionMode = "source-imports", verbose = false, allowOverwrite = false, cleanOutputDir = false, outputDirectory = "out/apis", resourcesFilePath = "cdk.itzworking.json", } = options;
+    if (targetTypeSystem !== "preserve-backend") {
+        console.error(`Unsupported targetTypeSystem: ${targetTypeSystem}. Only 'preserve-backend' is supported.`);
+        process.exit(1);
+    }
+    const resources = (0, utils_1.getITzWorkingResources)({ resourcesFilePath, verbose });
+    const apisByBasePath = (0, parse_discovered_apis_1.parseDiscoveredApis)(resources, {
+        tsConfigPath,
+        typeResolutionMode,
+        verbose,
+    });
+    if (cleanOutputDir) {
+        fs_1.default.rmSync(outputDirectory, { recursive: true, force: true });
+    }
+    (0, copy_api_client_1.copyApiClient)({ outputDirectory, allowOverwrite, verbose });
+    for (const [basePath, apis] of Object.entries(apisByBasePath)) {
+        (0, utils_1.writeFile)({
+            filePath: path_1.default.join(outputDirectory, (0, utils_1.toFileName)(basePath), "index.ts"),
+            content: `export * from "./${(0, utils_1.toFileName)(basePath)}-api";`,
+            allowOverwrite,
+            verbose,
+        });
+        const { apiClientClassFile, apiTypesFile } = (0, generate_api_client_class_1.generateApiClientClass)({ basePath, apis }, {
+            typeResolutionMode,
+            verbose,
+        });
+        (0, utils_1.writeFile)({
+            filePath: path_1.default.join(outputDirectory, (0, utils_1.toFileName)(basePath), `${(0, utils_1.toFileName)(basePath)}-api.ts`),
+            content: apiClientClassFile.replace(/^[\s\S]*?(?=import)/m, ""),
+            allowOverwrite,
+            verbose,
+        });
+        if (apiTypesFile) {
+            (0, utils_1.writeFile)({
+                filePath: path_1.default.join(outputDirectory, (0, utils_1.toFileName)(basePath), `types.ts`),
+                content: apiTypesFile,
+                allowOverwrite,
+                verbose,
+            });
+            fs_1.default.appendFileSync(path_1.default.join(outputDirectory, (0, utils_1.toFileName)(basePath), "index.ts"), `\nexport * from "./types";`);
+        }
+    }
+    for (const [basePath, apis] of Object.entries(apisByBasePath)) {
+        for (const api of apis) {
+            const { hookName, hookFile } = (0, generate_hook_1.generateHook)({ basePath, api }, {
+                typeResolutionMode,
+                verbose,
+            });
+            (0, utils_1.writeFile)({
+                filePath: path_1.default.join(outputDirectory, (0, utils_1.toFileName)(basePath), "hooks", `${(0, utils_1.toFileName)(hookName)}.ts`),
+                content: hookFile.replace(/^[\s\S]*?(?=import)/m, ""),
+                allowOverwrite,
+                verbose,
+            });
+        }
+    }
+};
+exports.generateApiClients = generateApiClients;

package/dist-cjs/generate-api-clients/generate-hook.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHook = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const template_loader_1 = require("./template-loader");
+const generateHook = ({ basePath, api, }, options) => {
+    const apiClassName = (0, utils_1.toClassName)(basePath) + "Api";
+    const actionName = (0, utils_1.toPropertyName)(api.actionName);
+    const actionClassName = (0, utils_1.toClassName)(api.actionName);
+    const hookName = `use${actionClassName}`;
+    const pathParams = (api.fullPath.match(/\{[^}]+}/g) || []).map((p) => p.replace(/[{}]/g, ""));
+    let mutationParams = "";
+    if (api.method !== "GET") {
+        if (pathParams.length > 0 || api.inputType) {
+            mutationParams += "variables: {\n";
+            if (pathParams.length > 0) {
+                mutationParams +=
+                    pathParams.map((p) => `      ${p}: string`).join(",\n") +
+                        (api.inputType ? ",\n" : "");
+            }
+            if (api.inputType) {
+                mutationParams += `      body: ${api.inputType.typeName}`;
+            }
+            mutationParams += "\n    }";
+        }
+    }
+    let queryKeyParams = "";
+    let queryKeyArray = "";
+    let queryKeyInput = "";
+    if (api.method === "GET") {
+        if (pathParams.length > 0) {
+            queryKeyParams = pathParams.map((p) => `${p}: string`).join(", ");
+            queryKeyInput = pathParams.map((p) => `${p}`).join(", ");
+        }
+        queryKeyArray = api.fullPath
+            .split("/")
+            .filter(Boolean)
+            .map((p) => {
+            if (p.startsWith("{") && p.endsWith("}")) {
+                return "  `$" + `${p}` + "`";
+            }
+            return `  "${p}"`;
+        })
+            .join(",\n");
+    }
+    const imports = [
+        { path: `../${(0, utils_1.toFileName)(apiClassName)}`, names: apiClassName },
+        ...(0, utils_1.prepareImports)(api, options).map((i) => i.path === "./types" ? { path: "../types", names: i.names } : i),
+    ];
+    const data = {
+        imports,
+        hookName,
+        mutationParams,
+        apiClassName,
+        actionName,
+        actionClassName,
+        relatedDataName: (0, utils_1.toPropertyName)(api.relatedDataName),
+        queryKeyParams,
+        queryKeyArray,
+        queryKeyInput,
+        outputType: api.outputType,
+    };
+    const templateFile = api.method === "GET" ? "hook-query.hbs" : "hook-mutation.hbs";
+    const templateSource = (0, template_loader_1.loadTemplate)(templateFile);
+    const template = handlebars_1.default.compile(templateSource);
+    const hookFile = template(data);
+    return { hookName, hookFile };
+};
+exports.generateHook = generateHook;

package/dist-cjs/generate-api-clients/handlebars-helpers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlebarsHelpers = void 0;
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const handlebarsHelpers = () => {
+    handlebars_1.default.registerHelper("eq", function (a, b) {
+        return a === b;
+    });
+    handlebars_1.default.registerHelper("lowercase", function (str) {
+        return typeof str === "string" ? str.toLowerCase() : str;
+    });
+};
+exports.handlebarsHelpers = handlebarsHelpers;

package/dist-cjs/generate-api-clients/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./generate-api-clients"), exports);

package/dist-cjs/generate-api-clients/parse-discovered-apis.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiscoveredApis = void 0;
+const tslib_1 = require("tslib");
+const ts_morph_1 = require("ts-morph");
+const path = tslib_1.__importStar(require("path"));
+const api_type_spec_utils_1 = require("./api-type-spec-utils");
+const INPUT_DECORATOR_NAME = "LambdaInput";
+const OUTPUT_DECORATOR_NAME = "LambdaOutput";
+const parseDiscoveredApis = (resources, options) => {
+    const parsedApis = {};
+    const project = new ts_morph_1.Project({
+        tsConfigFilePath: options.tsConfigPath,
+        skipAddingFilesFromTsConfig: true,
+    });
+    for (const stackResources of Object.values(resources.discoveredResources)) {
+        for (const api of stackResources.apis) {
+            const method = api.id.split("--")[0];
+            const fullPath = "/" + api.id.split("--").slice(1).join("/");
+            const basePath = fullPath.split("/")[1];
+            const handlerPath = path.join(api.folderPath, "handler.ts");
+            const sourceFile = project.addSourceFileAtPathIfExists(handlerPath);
+            if (!sourceFile)
+                continue;
+            const handlerVar = sourceFile.getVariableDeclaration("handler");
+            if (!handlerVar)
+                continue;
+            const initializer = handlerVar.getInitializer();
+            let className = null;
+            if (initializer && initializer.getKind() === ts_morph_1.SyntaxKind.CallExpression) {
+                const callExpr = initializer.asKind(ts_morph_1.SyntaxKind.CallExpression);
+                if (callExpr) {
+                    const expr = callExpr.getExpression();
+                    const exprText = expr.getText();
+                    className = exprText.split(".")[0];
+                }
+            }
+            if (!className)
+                continue;
+            const actionName = className.replace(/Lambda|lambda|Handler|handler/g, "");
+            const relatedDataName = actionName.replace(/^[A-Z][a-z]*/, "");
+            const classDecl = sourceFile.getClass(className);
+            if (!classDecl)
+                continue;
+            let inputTypeName = null;
+            let outputTypeName = null;
+            for (const decorator of classDecl.getDecorators()) {
+                const name = decorator.getName();
+                const args = decorator.getArguments();
+                if (name === INPUT_DECORATOR_NAME && args.length > 0) {
+                    inputTypeName = args[0].getText().replace(/\W/g, "");
+                }
+                if (name === OUTPUT_DECORATOR_NAME && args.length > 0) {
+                    outputTypeName = args[0].getText().replace(/\W/g, "");
+                }
+            }
+            const imports = {};
+            let inputImportPath = null;
+            let outputImportPath = null;
+            for (const importDecl of sourceFile.getImportDeclarations()) {
+                const namedImports = importDecl.getNamedImports();
+                for (const namedImport of namedImports) {
+                    const importName = namedImport.getName();
+                    const importPath = importDecl.getModuleSpecifierValue();
+                    if (inputTypeName && importName === inputTypeName) {
+                        inputImportPath = importPath;
+                        if (!imports[importPath])
+                            imports[importPath] = [];
+                        imports[importPath].push(importName);
+                    }
+                    if (outputTypeName && importName === outputTypeName) {
+                        outputImportPath = importPath;
+                        if (!imports[importPath])
+                            imports[importPath] = [];
+                        imports[importPath].push(importName);
+                    }
+                }
+            }
+            const inputType = inputTypeName
+                ? {
+                    typeName: inputTypeName,
+                    importPath: inputImportPath,
+                    typeDefinition: {
+                        allowedImports: [],
+                        inlinedFiles: [],
+                    },
+                    structure: null,
+                    kind: "unknown",
+                }
+                : null;
+            const outputType = outputTypeName
+                ? {
+                    typeName: outputTypeName,
+                    importPath: outputImportPath,
+                    typeDefinition: {
+                        allowedImports: [],
+                        inlinedFiles: [],
+                    },
+                    structure: null,
+                    kind: "unknown",
+                }
+                : null;
+            (0, api_type_spec_utils_1.setTypeKind)(inputType, sourceFile);
+            (0, api_type_spec_utils_1.setTypeKind)(outputType, sourceFile);
+            if (options.typeResolutionMode === "inline-types") {
+                (0, api_type_spec_utils_1.extractTypeDefinition)(inputType, sourceFile);
+                (0, api_type_spec_utils_1.extractTypeDefinition)(outputType, sourceFile);
+            }
+            if (!parsedApis[basePath]) {
+                parsedApis[basePath] = [];
+            }
+            parsedApis[basePath].push({
+                fullPath,
+                method,
+                actionName,
+                relatedDataName,
+                inputType,
+                outputType,
+                imports,
+            });
+        }
+    }
+    return parsedApis;
+};
+exports.parseDiscoveredApis = parseDiscoveredApis;