@pikku/inspector 0.6.4 → 0.7.1

package/dist/add-functions.js

@@ -0,0 +1,269 @@
+import * as ts from 'typescript';
+import { extractFunctionName, getPropertyAssignmentInitializer, } from './utils.js';
+const isValidVariableName = (name) => {
+    const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    return regex.test(name);
+};
+const nullifyTypes = (type) => {
+    if (type === 'void' ||
+        type === 'undefined' ||
+        type === 'unknown' ||
+        type === 'any') {
+        return null;
+    }
+    return type;
+};
+const resolveTypeImports = (type, resolvedTypes, isCustom) => {
+    const types = [];
+    const visitType = (currentType) => {
+        const symbol = currentType.aliasSymbol || currentType.getSymbol();
+        if (symbol) {
+            const declarations = symbol.getDeclarations();
+            const declaration = declarations?.[0];
+            if (declaration) {
+                const sourceFile = declaration.getSourceFile();
+                const path = sourceFile.fileName;
+                // Skip built-in utility types or TypeScript lib types
+                if (!path.includes('node_modules/typescript') &&
+                    symbol.getName() !== '__type' &&
+                    !isPrimitiveType(currentType)) {
+                    const originalName = symbol.getName();
+                    // Check if the type is already in the map
+                    let uniqueName = resolvedTypes.exists(originalName, path);
+                    if (!uniqueName) {
+                        if (isCustom) {
+                            uniqueName = resolvedTypes.addUniqueType(originalName, path);
+                        }
+                        else {
+                            resolvedTypes.addType(originalName, path);
+                            uniqueName = originalName;
+                        }
+                    }
+                    types.push(uniqueName);
+                }
+            }
+        }
+        if (isCustom) {
+            // Handle nested utility types like Partial, Pick, etc.
+            if (currentType.aliasTypeArguments) {
+                currentType.aliasTypeArguments.forEach(visitType);
+            }
+            // Handle intersections and unions
+            if (currentType.isUnionOrIntersection()) {
+                currentType.types.forEach(visitType);
+            }
+            // Handle object types with type arguments
+            if (currentType.flags & ts.TypeFlags.Object &&
+                currentType.objectFlags & ts.ObjectFlags.Reference) {
+                const typeRef = currentType;
+                typeRef.typeArguments?.forEach(visitType);
+            }
+        }
+    };
+    visitType(type);
+    return types;
+};
+const resolveUnionTypes = (checker, type) => {
+    const types = [];
+    const names = [];
+    // 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));
+            if (name) {
+                types.push(t);
+                names.push(name);
+            }
+        }
+    }
+    else {
+        const name = nullifyTypes(checker.typeToString(type));
+        if (name) {
+            types.push(type);
+            names.push(name);
+        }
+    }
+    return { types, names };
+};
+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) {
+        return {
+            names: ['void'],
+            types: [type],
+        };
+    }
+    // 2) For unions, resolve all member names/types
+    const { names: rawNames, types: rawTypes } = resolveUnionTypes(checker, type);
+    // If the union is exactly [void], we'd have caught it above.
+    // If it's e.g. [string, void], rawNames should already include 'void'.
+    // 3) If multiple names or the single name isn't a valid identifier,
+    //    we emit an alias 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;
+        // record the alias in your TypesMap
+        const references = rawTypes
+            .map((t) => resolveTypeImports(t, typesMap, true))
+            .flat();
+        typesMap.addCustomType(aliasName, aliasType, references);
+        return {
+            names: [aliasName],
+            types: rawTypes,
+        };
+    }
+    // 4) Single, valid name → inline it
+    const uniqueNames = rawNames
+        .map((name, i) => {
+        const t = rawTypes[i];
+        if (!t) {
+            throw new Error(`Expected type for name "${name}" in ${funcName}`);
+        }
+        if (isPrimitiveType(t)) {
+            return name;
+        }
+        // non-primitive: import/alias it inline
+        return resolveTypeImports(t, typesMap, false);
+    })
+        .flat();
+    return {
+        names: uniqueNames,
+        types: rawTypes,
+    };
+};
+const isPrimitiveType = (type) => {
+    const primitiveFlags = ts.TypeFlags.Number |
+        ts.TypeFlags.String |
+        ts.TypeFlags.Boolean |
+        ts.TypeFlags.BigInt |
+        ts.TypeFlags.ESSymbol |
+        ts.TypeFlags.Void |
+        ts.TypeFlags.Undefined |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Any |
+        ts.TypeFlags.Unknown |
+        ts.TypeFlags.VoidLike;
+    return (type.flags & primitiveFlags) !== 0;
+};
+/**
+ * If `type` is a `Promise<T>`, return `T`, otherwise return `type` itself.
+ */
+function unwrapPromise(checker, type) {
+    if (!type?.symbol)
+        return type;
+    const isPromise = type.symbol.name === 'Promise' &&
+        checker.getFullyQualifiedName(type.symbol).includes('Promise');
+    // aliasTypeArguments covers most Promise<T> cases
+    if (isPromise && type.aliasTypeArguments?.length === 1) {
+        return type.aliasTypeArguments[0];
+    }
+    // fallback for raw TypeReference
+    if (isPromise && type.typeArguments?.length === 1) {
+        return type.typeArguments[0];
+    }
+    return type;
+}
+/**
+ * Inspect pikkuFunc calls, extract input/output and first-arg destructuring,
+ * then push into state.functions.meta.
+ */
+export function addFunctions(node, checker, state, filters) {
+    if (!ts.isCallExpression(node))
+        return;
+    const { expression, arguments: args, typeArguments } = node;
+    // only handle calls like pikkuFunc(...)
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    // Match identifiers that contain both "pikku" and "func" (case insensitive)
+    const pikkuFuncPattern = /pikku.*func/i;
+    if (!pikkuFuncPattern.test(expression.text)) {
+        return;
+    }
+    // only handle calls like pikkuFunc(...)
+    if (!ts.isIdentifier(expression) || !expression.text.startsWith('pikku')) {
+        return;
+    }
+    if (args.length === 0)
+        return;
+    const { pikkuFuncName, name } = extractFunctionName(node, checker);
+    // determine the actual handler expression:
+    // either the `func` prop or the first argument directly
+    let handlerNode = args[0];
+    if (ts.isObjectLiteralExpression(handlerNode)) {
+        const fnProp = getPropertyAssignmentInitializer(handlerNode, 'func', true, checker);
+        if (!fnProp ||
+            (!ts.isArrowFunction(fnProp) && !ts.isFunctionExpression(fnProp))) {
+            console.error(`• No valid 'func' property found for ${pikkuFuncName}.`);
+            return;
+        }
+        handlerNode = fnProp;
+    }
+    if (!ts.isArrowFunction(handlerNode) &&
+        !ts.isFunctionExpression(handlerNode)) {
+        console.error(`• Handler for ${name} is not a function.`);
+        return;
+    }
+    const services = {
+        optimized: true,
+        services: [],
+    };
+    const firstParam = handlerNode.parameters[0];
+    if (firstParam) {
+        if (ts.isObjectBindingPattern(firstParam.name)) {
+            for (const elem of firstParam.name.elements) {
+                const original = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : ts.isIdentifier(elem.name)
+                        ? elem.name.text
+                        : undefined;
+                if (original) {
+                    services.services.push(original);
+                }
+            }
+        }
+        else if (ts.isIdentifier(firstParam.name) &&
+            !firstParam.name.text.startsWith('_')) {
+            services.optimized = false;
+        }
+    }
+    // --- Generics → ts.Type[], unwrapped from Promise ---
+    const genericTypes = (typeArguments ?? [])
+        .map((tn) => checker.getTypeFromTypeNode(tn))
+        .map((t) => unwrapPromise(checker, t));
+    // --- Input Extraction ---
+    let { names: inputNames, types: inputTypes } = getNamesAndTypes(checker, state.functions.typesMap, 'Input', name, genericTypes[0]);
+    if (inputTypes.length === 0) {
+        console.warn(`\x1b[31m• Unknown input type for '${name}', assuming void.\x1b[0m`);
+    }
+    // --- Output Extraction ---
+    let outputNames = [];
+    if (genericTypes.length >= 2) {
+        outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', name, genericTypes[1]).names;
+    }
+    else {
+        const sig = checker.getSignatureFromDeclaration(handlerNode);
+        if (sig) {
+            const rawRet = checker.getReturnTypeOfSignature(sig);
+            const unwrapped = unwrapPromise(checker, rawRet);
+            outputNames = getNamesAndTypes(checker, state.functions.typesMap, 'Output', pikkuFuncName, unwrapped).names;
+        }
+    }
+    // --- Record metadata ---
+    state.functions.files.add(node.getSourceFile().fileName);
+    if (inputNames.length > 1) {
+        console.warn('More than one input type detected, only the first one will be used as a schema.');
+    }
+    state.functions.meta[pikkuFuncName] = {
+        pikkuFuncName,
+        name,
+        services,
+        schemaName: inputNames[0] ?? null,
+        inputs: inputNames.filter((n) => n !== 'void') ?? null,
+        outputs: outputNames.filter((n) => n !== 'void') ?? null,
+    };
+}

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

@@ -1,4 +1,16 @@
 import * as ts from 'typescript';
-import { MetaInputTypes, InspectorState, InspectorFilters } from './types.js';
-export declare const getInputTypes: (metaTypes: MetaInputTypes, methodType: string, inputType: string | null, queryValues: string[], paramsValues: string[]) => undefined;
-export declare const addRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;
+import { InspectorState, InspectorFilters } from './types.js';
+/**
+ * Populate metaInputTypes for a given route based on method, input type,
+ * query and params. Returns undefined (we only mutate metaTypes).
+ */
+export declare const getInputTypes: (metaTypes: Map<string, {
+    query?: string[];
+    params?: string[];
+    body?: string[];
+}>, methodType: string, inputType: string | null, queryValues: string[], paramsValues: string[]) => undefined;
+/**
+ * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export declare const addHTTPRoute: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-http-route.js

@@ -1,93 +1,82 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
 import { pathToRegexp } from 'path-to-regexp';
-import { extractTypeKeys, getFunctionTypes, matchesFilters } from './utils.js';
+import { extractFunctionName, getPropertyAssignmentInitializer, matchesFilters, } from './utils.js';
+/**
+ * Populate metaInputTypes for a given route based on method, input type,
+ * query and params. Returns undefined (we only mutate metaTypes).
+ */
 export const getInputTypes = (metaTypes, methodType, inputType, queryValues, paramsValues) => {
-    if (!inputType) {
-        return undefined;
-    }
-    if (inputType) {
-        metaTypes.set(inputType, {
-            query: queryValues,
-            params: paramsValues,
-            body: ['post', 'put', 'patch'].includes(methodType)
-                ? [...new Set([...queryValues, ...paramsValues])]
-                : [],
-        });
-    }
-    return undefined;
+    if (!inputType)
+        return;
+    metaTypes.set(inputType, {
+        query: queryValues,
+        params: paramsValues,
+        body: ['post', 'put', 'patch'].includes(methodType)
+            ? [...new Set([...queryValues, ...paramsValues])]
+            : [],
+    });
+    return;
 };
-export const addRoute = (node, checker, state, filters) => {
-    if (!ts.isCallExpression(node)) {
+/**
+ * Simplified addHTTPRoute: re-uses function metadata from state.functions.meta
+ * instead of re-inferring types here.
+ */
+export const addHTTPRoute = (node, checker, state, filters) => {
+    // only look at calls
+    if (!ts.isCallExpression(node))
         return;
-    }
-    const args = node.arguments;
+    const { expression, arguments: args } = node;
+    if (!ts.isIdentifier(expression) || expression.text !== 'addHTTPRoute')
+        return;
+    // must pass an object literal
     const firstArg = args[0];
-    const expression = node.expression;
-    // Check if the call is to addRoute
-    if (!ts.isIdentifier(expression) || expression.text !== 'addRoute') {
+    if (!firstArg || !ts.isObjectLiteralExpression(firstArg))
+        return;
+    const obj = firstArg;
+    // --- extract HTTP metadata ---
+    const route = getPropertyValue(obj, 'route');
+    if (!route)
+        return;
+    const keys = pathToRegexp(route).keys;
+    const params = keys.filter((k) => k.type === 'param').map((k) => k.name);
+    const method = getPropertyValue(obj, 'method')?.toLowerCase() || 'get';
+    const docs = getPropertyValue(obj, 'docs') || undefined;
+    const tags = getPropertyValue(obj, 'tags') || undefined;
+    const query = getPropertyValue(obj, 'query') || [];
+    if (!matchesFilters(filters, { tags }, { type: 'http', name: route })) {
         return;
     }
-    if (!firstArg) {
+    // --- find the referenced function ---
+    const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
+    if (!funcInitializer) {
+        console.error(`• No valid 'func' property for route '${route}'.`);
         return;
     }
-    let docs;
-    let methodValue = null;
-    let paramsValues = [];
-    let queryValues = [];
-    let tags = [];
-    let routeValue = null;
-    // Check if the first argument is an object literal
-    if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        routeValue = getPropertyValue(obj, 'route');
-        if (!routeValue) {
-            return;
-        }
-        const { keys } = pathToRegexp(routeValue);
-        paramsValues = keys.reduce((result, { type, name }) => {
-            if (type === 'param') {
-                result.push(name);
-            }
-            return result;
-        }, []);
-        docs = getPropertyValue(obj, 'docs') || undefined;
-        methodValue = getPropertyValue(obj, 'method');
-        queryValues = getPropertyValue(obj, 'query') || [];
-        tags = getPropertyValue(obj, 'tags') || undefined;
-        if (!matchesFilters(filters, { tags }, { type: 'http', name: routeValue })) {
-            return;
-        }
-        let { inputs, outputs, inputTypes } = getFunctionTypes(checker, obj, {
-            funcName: 'func',
-            inputIndex: 0,
-            outputIndex: 1,
-            typesMap: state.http.typesMap,
-        });
-        const input = inputs ? inputs[0] || null : null;
-        const output = outputs ? outputs[0] || null : null;
-        if (inputs && inputs?.length > 1) {
-            console.error(`Only one input type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${inputs.join('\n\t')}`);
-        }
-        if (outputs && outputs?.length > 1) {
-            console.error(`Only one output type is currently allowed for method '${methodValue}' and route '${routeValue}': \n\t${outputs.join('\n\t')}`);
-        }
-        if (inputTypes[0] && !['post', 'put', 'patch'].includes(methodValue)) {
-            queryValues = [
-                ...new Set([...queryValues, ...extractTypeKeys(inputTypes[0])]),
-            ].filter((query) => !paramsValues?.includes(query));
-        }
-        state.http.files.add(node.getSourceFile().fileName);
-        state.http.meta.push({
-            route: routeValue,
-            method: methodValue,
-            input,
-            output,
-            params: paramsValues.length > 0 ? paramsValues : undefined,
-            query: queryValues.length > 0 ? queryValues : undefined,
-            inputTypes: getInputTypes(state.http.metaInputTypes, methodValue, input, queryValues, paramsValues),
-            docs,
-            tags,
-        });
+    const funcName = extractFunctionName(funcInitializer, checker).pikkuFuncName;
+    // lookup existing function metadata
+    const fnMeta = state.functions.meta[funcName];
+    if (!fnMeta) {
+        console.log(Object.keys(state.functions.meta));
+        console.error(`• No function metadata found for '${funcName}'.`);
+        return;
     }
+    const input = fnMeta.inputs?.[0] || null;
+    const output = fnMeta.outputs?.[0] || null;
+    // --- compute inputTypes (body/query/params) ---
+    const inputTypes = getInputTypes(state.http.metaInputTypes, method, input, query, params);
+    // --- record route ---
+    state.http.files.add(node.getSourceFile().fileName);
+    state.http.meta.push({
+        pikkuFuncName: funcName,
+        route,
+        method: method,
+        input,
+        output,
+        params: params.length > 0 ? params : undefined,
+        query: query.length > 0 ? query : undefined,
+        inputTypes,
+        docs,
+        tags,
+    });
 };

package/dist/add-schedule.d.ts

@@ -1,3 +1,3 @@
 import * as ts from 'typescript';
 import { InspectorFilters, InspectorState } from './types.js';
-export declare const addSchedule: (node: ts.Node, _checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;
+export declare const addSchedule: (node: ts.Node, checker: ts.TypeChecker, state: InspectorState, filters: InspectorFilters) => void;

package/dist/add-schedule.js

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { getPropertyValue } from './get-property-value.js';
-import { matchesFilters } from './utils.js';
-export const addSchedule = (node, _checker, state, filters) => {
+import { extractFunctionName, matchesFilters } from './utils.js';
+export const addSchedule = (node, checker, state, filters) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
@@ -21,6 +21,15 @@ export const addSchedule = (node, _checker, state, filters) => {
         const scheduleValue = getPropertyValue(obj, 'schedule');
         const docs = getPropertyValue(obj, 'docs') || undefined;
         const tags = getPropertyValue(obj, 'tags') || undefined;
+        // --- find the referenced function ---
+        const funcProp = obj.properties.find((p) => ts.isPropertyAssignment(p) &&
+            ts.isIdentifier(p.name) &&
+            p.name.text === 'func');
+        if (!funcProp || !ts.isIdentifier(funcProp.initializer)) {
+            console.error(`• No valid 'func' property for scheduled task '${nameValue}'.`);
+            return;
+        }
+        const pikkuFuncName = extractFunctionName(funcProp.initializer, checker).pikkuFuncName;
         if (!nameValue || !scheduleValue) {
             return;
         }
@@ -28,11 +37,12 @@ export const addSchedule = (node, _checker, state, filters) => {
             return;
         }
         state.scheduledTasks.files.add(node.getSourceFile().fileName);
-        state.scheduledTasks.meta.push({
+        state.scheduledTasks.meta[nameValue] = {
+            pikkuFuncName,
             name: nameValue,
             schedule: scheduleValue,
             docs,
             tags,
-        });
+        };
     }
 };

package/dist/inspector.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { visit } from './visit.js';
+import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 export const normalizeHTTPTypes = (httpState) => {
     return httpState;
@@ -18,6 +18,11 @@ export const inspect = (routeFiles, filters) => {
         singletonServicesFactories: new Map(),
         sessionServicesFactories: new Map(),
         configFactories: new Map(),
+        functions: {
+            typesMap: new TypesMap(),
+            meta: {},
+            files: new Set(),
+        },
         http: {
             typesMap: new TypesMap(),
             metaInputTypes: new Map(),
@@ -28,15 +33,20 @@ export const inspect = (routeFiles, filters) => {
             typesMap: new TypesMap(),
             metaInputTypes: new Map(),
             files: new Set(),
-            meta: [],
+            meta: {},
         },
         scheduledTasks: {
-            meta: [],
+            meta: {},
             files: new Set(),
         },
     };
+    // First sweep: add all functions
+    for (const sourceFile of sourceFiles) {
+        ts.forEachChild(sourceFile, (child) => visitSetup(checker, child, state, filters));
+    }
+    // Second sweep: add all transports
     for (const sourceFile of sourceFiles) {
-        ts.forEachChild(sourceFile, (child) => visit(checker, child, state, filters));
+        ts.forEachChild(sourceFile, (child) => visitRoutes(checker, child, state, filters));
     }
     // Normalise the typesMap
     state.http = normalizeHTTPTypes(state.http);

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import { ChannelsMeta } from '@pikku/core/channel';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
 import { TypesMap } from './types-map.js';
+import { FunctionsMeta } from '@pikku/core';
 export type PathToNameAndType = Map<string, {
     variable: string;
     type: string | null;
@@ -12,22 +13,17 @@ export type MetaInputTypes = Map<string, {
     params: string[] | undefined;
     body: string[] | undefined;
 }>;
-export type APIFunctionMeta = Array<{
-    name: string;
-    input: string;
-    output: string;
-    file: string;
-}>;
-export type InspectorAPIFunction = {
-    typesMap: TypesMap;
-    meta: APIFunctionMeta;
-};
 export interface InspectorHTTPState {
     typesMap: TypesMap;
     metaInputTypes: MetaInputTypes;
     meta: HTTPRoutesMeta;
     files: Set<string>;
 }
+export interface InspectorFunctionState {
+    typesMap: TypesMap;
+    meta: FunctionsMeta;
+    files: Set<string>;
+}
 export interface InspectorChannelState {
     typesMap: TypesMap;
     metaInputTypes: MetaInputTypes;
@@ -45,6 +41,7 @@ export interface InspectorState {
     sessionServicesFactories: PathToNameAndType;
     configFactories: PathToNameAndType;
     http: InspectorHTTPState;
+    functions: InspectorFunctionState;
     channels: InspectorChannelState;
     scheduledTasks: {
         meta: ScheduledTasksMeta;

package/dist/utils.d.ts

@@ -1,34 +1,28 @@
 import * as ts from 'typescript';
-import { TypesMap } from './types-map.js';
 import { InspectorFilters } from './types.js';
-type FunctionTypes = {
-    type: string | null;
-    inputTypes: ts.Type[];
-    inputs: null | string[];
-    outputTypes: ts.Type[];
-    outputs: null | string[];
+type ExtractedFunctionName = {
+    pikkuFuncName: string;
+    name: string;
+    exportedName: string | null;
+    functionName: string | null;
+    propertyName: string | null;
 };
+/**
+ * Generate a deterministic "anonymous" name for any expression node,
+ * but if it's an Identifier pointing to a function, resolve it back
+ * to the function's declaration (so you get the true source location).
+ */
+export declare function makeDeterministicAnonName(start: ts.Node, checker: ts.TypeChecker): string;
+/**
+ * Updated function to extract and prioritize function names correctly
+ * This function follows the priority:
+ * 1. Object with a name property
+ * 2. Exported name
+ * 3. Fallback to deterministic name
+ */
+export declare function extractFunctionName(callExpr: ts.Node, checker: ts.TypeChecker): ExtractedFunctionName;
 export declare const extractTypeKeys: (type: ts.Type) => string[];
-export declare const nullifyTypes: (type: string | null) => string | null;
-export declare const getNamesAndTypes: (checker: ts.TypeChecker, typesMap: TypesMap, direction: "Input" | "Output", funcName: string, type: ts.Type) => {
-    names: string[];
-    types: ts.Type[];
-};
-export declare const isPrimitiveType: (type: ts.Type) => boolean;
-export declare const resolveUnionTypes: (checker: ts.TypeChecker, type: ts.Type) => {
-    types: ts.Type[];
-    names: string[];
-};
-export declare const resolveTypeImports: (type: ts.Type, resolvedTypes: TypesMap, isCustom: boolean) => string[];
-export declare const getPropertyAssignment: (obj: ts.ObjectLiteralExpression, name: string) => ts.ObjectLiteralElementLike | null;
-export declare const getTypeArgumentsOfType: (checker: ts.TypeChecker, type: ts.Type) => readonly ts.Type[] | null;
-export declare const getFunctionTypes: (checker: ts.TypeChecker, obj: ts.ObjectLiteralExpression, { typesMap, funcName, subFunctionName, inputIndex, outputIndex, }: {
-    typesMap: TypesMap;
-    subFunctionName?: string;
-    funcName: string;
-    inputIndex: number;
-    outputIndex: number;
-}) => FunctionTypes;
+export declare function getPropertyAssignmentInitializer(obj: ts.ObjectLiteralExpression, propName: string, followShorthand?: boolean, checker?: ts.TypeChecker): ts.Expression | undefined;
 export declare const matchesFilters: (filters: InspectorFilters, params: {
     tags?: string[];
 }, meta: {