@pikku/inspector 0.11.1 → 0.12.0

package/dist/add/add-functions.js

@@ -1,8 +1,14 @@
 import * as ts from 'typescript';
-import { extractFunctionName } from '../utils/extract-function-name.js';
+import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js';
+import { extractFunctionName, funcIdToTypeName, } from '../utils/extract-function-name.js';
 import { extractFunctionNode } from '../utils/extract-function-node.js';
+import { extractUsedWires } from '../utils/extract-services.js';
+import { formatVersionedId } from '@pikku/core';
 import { getPropertyValue, getCommonWireMetaData, } from '../utils/get-property-value.js';
 import { resolveMiddleware } from '../utils/middleware.js';
+import { resolvePermissions } from '../utils/permissions.js';
+import { extractWireNames } from '../utils/post-process.js';
+import { ErrorCode } from '../error-codes.js';
 const isValidVariableName = (name) => {
     const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     return regex.test(name);
@@ -11,7 +17,8 @@ const nullifyTypes = (type) => {
     if (type === 'void' ||
         type === 'undefined' ||
         type === 'unknown' ||
-        type === 'any') {
+        type === 'any' ||
+        type === 'null') {
         return null;
     }
     return type;
@@ -109,7 +116,7 @@ const resolveUnionTypes = (checker, type) => {
     // Check if it's a union type AND not part of an intersection
     if (type.isUnion() && !(type.flags & ts.TypeFlags.Intersection)) {
         for (const t of type.types) {
-            const name = nullifyTypes(checker.typeToString(t));
+            const name = nullifyTypes(checker.typeToString(t, undefined, ts.TypeFormatFlags.NoTruncation));
             if (name) {
                 types.push(t);
                 names.push(name);
@@ -117,7 +124,7 @@ const resolveUnionTypes = (checker, type) => {
         }
     }
     else {
-        const name = nullifyTypes(checker.typeToString(type));
+        const name = nullifyTypes(checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation));
         if (name) {
             types.push(type);
             names.push(name);
@@ -129,8 +136,8 @@ const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
     if (!type) {
         return { names: [], types: [] };
     }
-    // 1) Handle an explicit void (or undefined) type up front
-    if (type.flags & ts.TypeFlags.VoidLike) {
+    // 1) Handle an explicit void (or undefined or null) type up front
+    if (type.flags & (ts.TypeFlags.VoidLike | ts.TypeFlags.Null)) {
         return {
             names: [],
             types: [],
@@ -145,7 +152,7 @@ const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
     const firstName = rawNames[0];
     if (rawNames.length > 1 || (firstName && !isValidVariableName(firstName))) {
         const aliasType = rawNames.join(' | ');
-        const aliasName = funcName.charAt(0).toUpperCase() + funcName.slice(1) + direction;
+        const aliasName = funcIdToTypeName(funcName) + direction;
         // record the alias in your TypesMap
         const references = rawTypes
             .map((t) => resolveTypeImports(t, typesMap, true, checker))
@@ -184,7 +191,6 @@ const isPrimitiveType = (type) => {
         ts.TypeFlags.Void |
         ts.TypeFlags.Undefined |
         ts.TypeFlags.Null |
-        ts.TypeFlags.Any |
         ts.TypeFlags.Unknown |
         ts.TypeFlags.VoidLike;
     return (type.flags & primitiveFlags) !== 0;
@@ -211,7 +217,7 @@ function unwrapPromise(checker, type) {
  * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
  * then push into state.functions.meta.
  */
-export const addFunctions = (logger, node, checker, state) => {
+export const addFunctions = (logger, node, checker, state, options) => {
     if (!ts.isCallExpression(node))
         return;
     const { expression, arguments: args, typeArguments } = node;
@@ -230,28 +236,153 @@ export const addFunctions = (logger, node, checker, state) => {
     }
     if (args.length === 0)
         return;
-    const { pikkuFuncName, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    let { pikkuFuncId, name, explicitName, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    if (!pikkuFuncId || pikkuFuncId.startsWith('__temp_')) {
+        return;
+    }
+    let title;
     let tags;
     let summary;
     let description;
     let errors;
     let expose;
-    let internal;
+    let remote;
+    let mcp;
+    let requiresApproval;
+    let version;
     let objectNode;
+    let nodeDisplayName = null;
+    let nodeCategory = null;
+    let nodeType = null;
+    let nodeErrorOutput = null;
     // Extract the function node using shared utility
     const firstArg = args[0];
     const { funcNode: handlerNode, resolvedFunc, isDirectFunction, } = extractFunctionNode(firstArg, checker);
+    // Variables to hold schema references if provided
+    let inputSchemaRef = null;
+    let outputSchemaRef = null;
+    // Helper to resolve schema identifier to its actual source file and detect vendor.
+    // Logs a fatal error and returns null if vendor cannot be determined.
+    const resolveSchemaRef = (identifier, context) => {
+        const symbol = checker.getSymbolAtLocation(identifier);
+        if (!symbol)
+            return null;
+        const decl = symbol.valueDeclaration || symbol.declarations?.[0];
+        if (!decl)
+            return null;
+        let sourceFile;
+        // If it's an import specifier, resolve the aliased symbol to get the actual source
+        if (ts.isImportSpecifier(decl)) {
+            const aliasedSymbol = checker.getAliasedSymbol(symbol);
+            if (aliasedSymbol) {
+                const aliasedDecl = aliasedSymbol.valueDeclaration || aliasedSymbol.declarations?.[0];
+                if (aliasedDecl) {
+                    sourceFile = aliasedDecl.getSourceFile().fileName;
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            sourceFile = decl.getSourceFile().fileName;
+        }
+        const vendor = detectSchemaVendorOrError(identifier, checker, logger, context, sourceFile);
+        if (!vendor)
+            return null;
+        return {
+            variableName: identifier.text,
+            sourceFile,
+            vendor,
+        };
+    };
     // Extract config properties if using object form
     if (ts.isObjectLiteralExpression(firstArg)) {
         objectNode = firstArg;
         const metadata = getCommonWireMetaData(firstArg, 'Function', name, logger);
+        if (metadata.disabled)
+            return;
+        title = metadata.title;
         tags = metadata.tags;
         summary = metadata.summary;
         description = metadata.description;
         errors = metadata.errors;
         expose = getPropertyValue(firstArg, 'expose');
-        internal = getPropertyValue(firstArg, 'internal');
+        remote = getPropertyValue(firstArg, 'remote');
+        mcp = getPropertyValue(firstArg, 'mcp');
+        requiresApproval = getPropertyValue(firstArg, 'requiresApproval');
+        const versionRaw = getPropertyValue(firstArg, 'version');
+        if (versionRaw !== null && versionRaw !== undefined) {
+            const parsed = Number(versionRaw);
+            if (Number.isInteger(parsed) && parsed >= 1) {
+                version = parsed;
+            }
+        }
+        // Extract node config from nested object
+        for (const prop of firstArg.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'node' &&
+                ts.isObjectLiteralExpression(prop.initializer)) {
+                const nodeObj = prop.initializer;
+                nodeDisplayName = getPropertyValue(nodeObj, 'displayName');
+                nodeCategory = getPropertyValue(nodeObj, 'category');
+                nodeType = getPropertyValue(nodeObj, 'type');
+                nodeErrorOutput = getPropertyValue(nodeObj, 'errorOutput');
+                if (!nodeDisplayName) {
+                    logger.critical(ErrorCode.MISSING_NAME, `Function '${name}' node config is missing the required 'displayName' property.`);
+                }
+                if (!nodeCategory) {
+                    logger.critical(ErrorCode.MISSING_NAME, `Function '${name}' node config is missing the required 'category' property.`);
+                }
+                if (!nodeType) {
+                    logger.critical(ErrorCode.MISSING_NAME, `Function '${name}' node config is missing the required 'type' property.`);
+                }
+                else if (!['trigger', 'action', 'end'].includes(nodeType)) {
+                    logger.critical(ErrorCode.INVALID_VALUE, `Function '${name}' node config has invalid type '${nodeType}'. Must be 'trigger', 'action', or 'end'.`);
+                }
+                break;
+            }
+        }
+        // Extract schema variable names from input/output properties
+        for (const prop of firstArg.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const propName = prop.name.text;
+                if (propName === 'input' || propName === 'output') {
+                    if (ts.isIdentifier(prop.initializer)) {
+                        // Good - it's a variable reference, resolve its actual source file and vendor
+                        const context = `Function '${name}' ${propName}`;
+                        const ref = resolveSchemaRef(prop.initializer, context);
+                        if (ref) {
+                            if (propName === 'input') {
+                                inputSchemaRef = ref;
+                            }
+                            else {
+                                outputSchemaRef = ref;
+                            }
+                        }
+                    }
+                    else if (ts.isCallExpression(prop.initializer)) {
+                        // Bad - it's an inline expression
+                        const schemaName = `${funcIdToTypeName(name)}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+                        logger.critical(ErrorCode.INLINE_SCHEMA, `Inline schemas are not supported for '${propName}' in '${name}'.\n` +
+                            `  Extract to an exported variable:\n` +
+                            `    export const ${schemaName} = ${prop.initializer.getText()}\n` +
+                            `  Then use: ${propName}: ${schemaName}`);
+                    }
+                }
+            }
+        }
+    }
+    if (version !== undefined) {
+        const baseName = explicitName || exportedName || pikkuFuncId;
+        pikkuFuncId = formatVersionedId(baseName, version);
     }
+    const isMCPToolFunc = expression.text === 'pikkuMCPToolFunc';
+    const mcpEnabled = mcp || isMCPToolFunc;
     // Pick the handler: use resolvedFunc when it exists and is a function, otherwise fall back to handlerNode
     const handler = resolvedFunc &&
         (ts.isArrowFunction(resolvedFunc) || ts.isFunctionExpression(resolvedFunc))
@@ -259,10 +390,11 @@ export const addFunctions = (logger, node, checker, state) => {
         : handlerNode;
     // Validate that we got a valid function
     if (!ts.isArrowFunction(handler) && !ts.isFunctionExpression(handler)) {
-        logger.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
+        logger.error(`• No valid 'func' property found for ${pikkuFuncId}.`);
         // Create stub metadata to prevent "function not found" errors in wirings
-        state.functions.meta[pikkuFuncName] = {
-            pikkuFuncName,
+        state.functions.meta[pikkuFuncId] = {
+            pikkuFuncId,
+            functionType: 'user',
             name,
             services: { optimized: false, services: [] },
             inputSchemaName: null,
@@ -291,39 +423,51 @@ export const addFunctions = (logger, node, checker, state) => {
                 }
             }
         }
-        else if (ts.isIdentifier(firstParam.name)) {
+        else if (ts.isIdentifier(firstParam.name) &&
+            !firstParam.name.text.startsWith('_')) {
             services.optimized = false;
         }
     }
-    // --- Extract used wires from third parameter ---
-    const usedWires = [];
-    const thirdParam = handler.parameters[2];
-    if (thirdParam && ts.isObjectBindingPattern(thirdParam.name)) {
-        for (const elem of thirdParam.name.elements) {
-            const propertyName = elem.propertyName && ts.isIdentifier(elem.propertyName)
-                ? elem.propertyName.text
-                : ts.isIdentifier(elem.name)
-                    ? elem.name.text
-                    : undefined;
-            if (propertyName) {
-                usedWires.push(propertyName);
-            }
-        }
-    }
+    const wires = extractUsedWires(handler, 2);
     // --- Generics → ts.Type[], unwrapped from Promise ---
     const genericTypes = (typeArguments ?? [])
         .map((tn) => checker.getTypeFromTypeNode(tn))
         .map((t) => unwrapPromise(checker, t));
+    const capitalizedName = funcIdToTypeName(name);
     // --- Input Extraction ---
-    let { names: inputNames, types: inputTypes } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
-    // if (inputTypes.length === 0) {
-    //   logger.debug(
-    //     `\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`
-    //   )
-    // }
+    let inputNames = [];
+    let inputTypes = [];
+    if (inputSchemaRef) {
+        const schemaName = `${capitalizedName}Input`;
+        inputNames = [schemaName];
+        state.schemaLookup.set(schemaName, inputSchemaRef);
+        state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
+    }
+    else if (genericTypes.length >= 1 && genericTypes[0]) {
+        // Fall back to extracting from generic type arguments
+        const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
+        inputNames = result.names;
+        inputTypes = result.types;
+    }
+    else {
+        // Fall back to extracting from the function's second parameter type
+        const secondParam = handler.parameters[1];
+        if (secondParam) {
+            const paramType = checker.getTypeAtLocation(secondParam);
+            const result = getNamesAndTypes(checker, state.functions.typesMap, 'Input', pikkuFuncId, paramType);
+            inputNames = result.names;
+            inputTypes = result.types;
+        }
+    }
     // --- Output Extraction ---
     let outputNames = [];
-    if (genericTypes.length >= 2) {
+    if (outputSchemaRef) {
+        const schemaName = `${capitalizedName}Output`;
+        outputNames = [schemaName];
+        state.schemaLookup.set(schemaName, outputSchemaRef);
+        state.functions.typesMap.addCustomType(schemaName, 'unknown', []);
+    }
+    else if (genericTypes.length >= 2) {
         outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
     }
     else {
@@ -331,74 +475,198 @@ export const addFunctions = (logger, node, checker, state) => {
         if (sig) {
             const rawRet = checker.getReturnTypeOfSignature(sig);
             const unwrapped = unwrapPromise(checker, rawRet);
-            outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', pikkuFuncName, unwrapped).names;
+            outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', pikkuFuncId, unwrapped).names;
+        }
+    }
+    const mcpOutputTypes = {
+        pikkuMCPResourceFunc: 'MCPResourceResponse',
+        pikkuMCPToolFunc: 'MCPToolResponse',
+        pikkuMCPPromptFunc: 'MCPPromptResponse',
+    };
+    const mcpOutputType = mcpOutputTypes[expression.text];
+    if (mcpOutputType && outputNames[0] !== mcpOutputType) {
+        let resolved = false;
+        const rawSymbol = checker.getSymbolAtLocation(expression);
+        const funcSymbol = rawSymbol && rawSymbol.flags & ts.SymbolFlags.Alias
+            ? checker.getAliasedSymbol(rawSymbol)
+            : rawSymbol;
+        const funcDecls = funcSymbol?.getDeclarations() || [];
+        for (const funcDecl of funcDecls) {
+            if (resolved)
+                break;
+            const mcpTypeSymbol = checker.resolveName(mcpOutputType, funcDecl, ts.SymbolFlags.Type, false);
+            if (mcpTypeSymbol) {
+                const aliased = mcpTypeSymbol.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(mcpTypeSymbol)
+                    : mcpTypeSymbol;
+                const typeDecl = aliased?.getDeclarations()?.[0];
+                if (typeDecl) {
+                    const path = typeDecl.getSourceFile().fileName;
+                    if (!state.functions.typesMap.exists(mcpOutputType, path)) {
+                        state.functions.typesMap.addType(mcpOutputType, path);
+                    }
+                    resolved = true;
+                }
+            }
+        }
+        if (!resolved) {
+            state.functions.typesMap.addCustomType(mcpOutputType, mcpOutputType, []);
         }
+        outputNames = [mcpOutputType];
     }
     if (inputNames.length > 1) {
         logger.warn('More than one input type detected, only the first one will be used as a schema.');
     }
     // Store the input type for later use
     if (inputTypes.length > 0) {
-        state.typesLookup.set(pikkuFuncName, inputTypes);
+        state.typesLookup.set(pikkuFuncId, inputTypes);
     }
     // --- resolve middleware ---
-    const middleware = objectNode
+    let middleware = objectNode
         ? resolveMiddleware(state, objectNode, tags, checker)
         : undefined;
-    state.functions.meta[pikkuFuncName] = {
-        pikkuFuncName,
+    // --- resolve permissions ---
+    let permissions = objectNode
+        ? resolvePermissions(state, objectNode, tags, checker)
+        : undefined;
+    if (options.tags?.length) {
+        tags = [...new Set([...(tags || []), ...options.tags])];
+        const tagEntries = options.tags.map((tag) => ({
+            type: 'tag',
+            tag,
+        }));
+        const existingMiddlewareTags = new Set((middleware || [])
+            .filter((m) => m.type === 'tag')
+            .map((m) => m.tag));
+        const newMiddleware = tagEntries.filter((e) => !existingMiddlewareTags.has(e.tag));
+        if (newMiddleware.length > 0) {
+            middleware = [...(middleware || []), ...newMiddleware];
+        }
+        const existingPermissionTags = new Set((permissions || [])
+            .filter((p) => p.type === 'tag')
+            .map((p) => p.tag));
+        const newPermissions = tagEntries.filter((e) => !existingPermissionTags.has(e.tag));
+        if (newPermissions.length > 0) {
+            permissions = [...(permissions || []), ...newPermissions];
+        }
+    }
+    const sessionless = expression.text !== 'pikkuFunc';
+    state.functions.meta[pikkuFuncId] = {
+        pikkuFuncId,
+        functionType: 'user',
+        funcWrapper: expression.text,
+        sessionless,
         name,
         services,
-        usedWires: usedWires.length > 0 ? usedWires : undefined,
+        wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
         inputSchemaName: inputNames[0] ?? null,
         outputSchemaName: outputNames[0] ?? null,
         inputs: inputNames.filter((n) => n !== 'void') ?? null,
         outputs: outputNames.filter((n) => n !== 'void') ?? null,
         expose: expose || undefined,
-        internal: internal || undefined,
+        remote: remote || undefined,
+        mcp: mcpEnabled || undefined,
+        requiresApproval: requiresApproval || undefined,
+        version,
+        title,
         tags: tags || undefined,
         summary,
         description,
         errors,
         middleware,
+        permissions,
         isDirectFunction,
     };
+    // Populate node metadata if node config is present
+    if (nodeDisplayName && nodeCategory && nodeType) {
+        state.nodes.files.add(node.getSourceFile().fileName);
+        state.nodes.meta[pikkuFuncId] = {
+            name: pikkuFuncId,
+            displayName: nodeDisplayName,
+            category: nodeCategory,
+            type: nodeType,
+            rpc: pikkuFuncId,
+            description,
+            errorOutput: nodeErrorOutput ?? false,
+            inputSchemaName: inputNames[0] ?? null,
+            outputSchemaName: outputNames[0] ?? null,
+            tags,
+        };
+    }
+    if (mcpEnabled) {
+        if (!description) {
+            logger.critical(ErrorCode.MISSING_DESCRIPTION, `MCP tool '${name}' is missing a description.`);
+            return;
+        }
+        state.mcpEndpoints.files.add(node.getSourceFile().fileName);
+        state.mcpEndpoints.toolsMeta[name] = {
+            pikkuFuncId,
+            name,
+            title: title || undefined,
+            description,
+            summary,
+            errors,
+            tags,
+            inputSchema: inputNames[0] ?? null,
+            outputSchema: outputNames[0] ?? null,
+            middleware,
+            permissions,
+        };
+        state.serviceAggregation.usedFunctions.add(pikkuFuncId);
+        extractWireNames(middleware).forEach((n) => state.serviceAggregation.usedMiddleware.add(n));
+        extractWireNames(permissions).forEach((n) => state.serviceAggregation.usedPermissions.add(n));
+    }
+    // Workflow functions don't get registered as RPC functions,
+    // they are their own type handled by add-workflow
+    if (expression.text.includes('Workflow')) {
+        return;
+    }
+    // Trigger and channel connect/disconnect functions are not callable via RPC
+    const nonRPCPatterns = [
+        /Trigger/i,
+        /ChannelConnection/i,
+        /ChannelDisconnection/i,
+    ];
+    if (nonRPCPatterns.some((pattern) => pattern.test(expression.text))) {
+        return;
+    }
     // Store function file location for wiring generation
     if (exportedName) {
-        state.functions.files.set(pikkuFuncName, {
+        state.functions.files.set(pikkuFuncId, {
             path: node.getSourceFile().fileName,
             exportedName,
         });
     }
-    // Workflow functions don't get registered as RPC functions,
-    // they are their own type handled by add-workdflow
-    if (expression.text.includes('Workflow')) {
-        return;
-    }
     if (exportedName || explicitName) {
         if (!exportedName) {
             logger.error(`• Function with explicit name '${name}' is not exported, this is not allowed.`);
             return;
         }
-        // Mark internal functions as invoked to force bundling
-        if (internal) {
-            state.rpc.invokedFunctions.add(pikkuFuncName);
+        if (remote) {
+            state.rpc.invokedFunctions.add(pikkuFuncId);
         }
         if (expose) {
-            state.rpc.exposedMeta[name] = pikkuFuncName;
+            state.rpc.exposedMeta[name] = pikkuFuncId;
             state.rpc.exposedFiles.set(name, {
                 path: node.getSourceFile().fileName,
                 exportedName,
             });
             // Track exposed RPC function for service aggregation
-            state.serviceAggregation.usedFunctions.add(pikkuFuncName);
+            state.serviceAggregation.usedFunctions.add(pikkuFuncId);
         }
         // We add it to internal meta to allow autocomplete for everything
-        state.rpc.internalMeta[name] = pikkuFuncName;
+        state.rpc.internalMeta[name] = pikkuFuncId;
+        if (version !== undefined) {
+            state.rpc.internalMeta[pikkuFuncId] = pikkuFuncId;
+            state.rpc.invokedFunctions.add(pikkuFuncId);
+        }
         // But we only import the actual function if it's actually invoked to keep
         // bundle size down
-        if (state.rpc.invokedFunctions.has(pikkuFuncName) || expose || internal) {
-            state.rpc.internalFiles.set(pikkuFuncName, {
+        if (state.rpc.invokedFunctions.has(pikkuFuncId) ||
+            expose ||
+            remote ||
+            mcpEnabled) {
+            state.rpc.internalFiles.set(pikkuFuncId, {
                 path: node.getSourceFile().fileName,
                 exportedName,
             });

package/dist/add/add-http-route.d.ts

@@ -1,15 +1,24 @@
-import { AddWiring } from '../types.js';
+import * as ts from 'typescript';
+import { AddWiring, InspectorState } from '../types.js';
+import type { InspectorLogger } from '../types.js';
 /**
- * Populate metaInputTypes for a given route based on method, input type,
- * query and params. Returns undefined (we only mutate metaTypes).
+ * Parameters for registering an HTTP route
  */
-export declare const getInputTypes: (metaTypes: Map<string, {
-    query?: string[];
-    params?: string[];
-    body?: string[];
-}>, methodType: string, inputType: string | null, queryValues: string[], paramsValues: string[]) => undefined;
+export interface RegisterHTTPRouteParams {
+    obj: ts.ObjectLiteralExpression;
+    state: InspectorState;
+    checker: ts.TypeChecker;
+    logger: InspectorLogger;
+    sourceFile: ts.SourceFile;
+    basePath?: string;
+    inheritedTags?: string[];
+}
 /**
- * Simplified wireHTTP: re-uses function metadata from state.functions.meta
- * instead of re-inferring types here.
+ * Shared function to register an HTTP route in the inspector state.
+ * Used by both wireHTTP and wireHTTPRoutes.
+ */
+export declare function registerHTTPRoute({ obj, state, checker, logger, sourceFile, basePath, inheritedTags, }: RegisterHTTPRouteParams): void;
+/**
+ * Process wireHTTP calls
  */
 export declare const addHTTPRoute: AddWiring;