@dropins/mcp 0.1.0

package/dist/operations/check-config.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const CheckConfigSchema: z.ZodObject<{
+    projectDir: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectDir: string;
+}, {
+    projectDir: string;
+}>;
+export declare function checkConfig(params: z.infer<typeof CheckConfigSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/check-config.js

@@ -0,0 +1,228 @@
+import { createHash } from "crypto";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { readPackageJson, readConfigJson, listBlocks, readBlockFile, listInitializers, projectDirGuard, extractDropinDependencies, extractImportsFromBlock, } from "../common/project-reader.js";
+const DROPIN_ENTRY_FILES = ["api.js", "render.js", "fragments.js"];
+function fileHash(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return createHash("sha256").update(readFileSync(filePath)).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+function checkDropinFileIntegrity(projectDir) {
+    const issues = [];
+    const dropinsDir = join(projectDir, "scripts", "__dropins__");
+    const nodeModulesDropins = join(projectDir, "node_modules", "@dropins");
+    if (!existsSync(dropinsDir) || !existsSync(nodeModulesDropins))
+        return issues;
+    let dropinFolders;
+    try {
+        dropinFolders = readdirSync(dropinsDir);
+    }
+    catch {
+        return issues;
+    }
+    for (const dropin of dropinFolders) {
+        const installedDir = join(dropinsDir, dropin);
+        const sourceDir = join(nodeModulesDropins, dropin);
+        if (!existsSync(sourceDir))
+            continue;
+        for (const file of DROPIN_ENTRY_FILES) {
+            const installedPath = join(installedDir, file);
+            const sourcePath = join(sourceDir, file);
+            const installedHash = fileHash(installedPath);
+            const sourceHash = fileHash(sourcePath);
+            if (installedHash === null || sourceHash === null)
+                continue;
+            if (installedHash !== sourceHash) {
+                issues.push({
+                    level: "warning",
+                    area: "dropin-integrity",
+                    message: `scripts/__dropins__/${dropin}/${file} has been manually modified and will be silently overwritten on the next npm update`,
+                    fix: `Revert changes to scripts/__dropins__/${dropin}/${file} and use slots, events, or CSS custom properties to customise dropin behaviour instead`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+export const CheckConfigSchema = z.object({
+    projectDir: z
+        .string()
+        .describe("Absolute path to the merchant storefront project root"),
+});
+export async function checkConfig(params) {
+    try {
+        const guard = projectDirGuard(params.projectDir);
+        if (guard)
+            return guard;
+        const issues = [];
+        const pkg = readPackageJson(params.projectDir);
+        if (!pkg) {
+            issues.push({
+                level: "error",
+                area: "package.json",
+                message: "No package.json found in project root",
+                fix: "Run npm init or ensure you are pointing to the correct directory",
+            });
+        }
+        else {
+            const dropinDeps = extractDropinDependencies(pkg);
+            const hasTools = dropinDeps.some((d) => d.name === "@dropins/tools");
+            if (!hasTools) {
+                issues.push({
+                    level: "error",
+                    area: "dependencies",
+                    message: "@dropins/tools is not installed — required by all dropins",
+                    fix: "Run: npm install @dropins/tools",
+                });
+            }
+            const prodDropins = dropinDeps.filter((d) => !d.isDev &&
+                d.name !== "@dropins/tools" &&
+                d.name !== "@dropins/build-tools");
+            if (prodDropins.length === 0) {
+                issues.push({
+                    level: "warning",
+                    area: "dependencies",
+                    message: "No dropin dependencies found (besides tools)",
+                    fix: "Install at least one dropin, e.g.: npm install @dropins/storefront-cart",
+                });
+            }
+            const tildeVersions = dropinDeps.filter((d) => d.version.startsWith("~"));
+            const caretVersions = dropinDeps.filter((d) => d.version.startsWith("^"));
+            if (caretVersions.length > 0) {
+                issues.push({
+                    level: "info",
+                    area: "versions",
+                    message: `${caretVersions.length} dropin(s) use caret (^) versioning which may pull breaking changes`,
+                    fix: "Consider using tilde (~) for dropin versions to restrict to patch updates",
+                });
+            }
+            const mixedVersioning = tildeVersions.length > 0 && caretVersions.length > 0;
+            if (mixedVersioning) {
+                issues.push({
+                    level: "warning",
+                    area: "versions",
+                    message: "Mixed versioning strategies detected across dropin dependencies",
+                    fix: "Standardize on either tilde (~) or caret (^) for all dropin dependencies",
+                });
+            }
+        }
+        const config = readConfigJson(params.projectDir);
+        if (!config) {
+            issues.push({
+                level: "error",
+                area: "config.json",
+                message: "No config.json or demo-config.json found",
+                fix: "Create a config.json with commerce-endpoint and commerce-core-endpoint",
+            });
+        }
+        else {
+            const defaultConfig = config.public?.default;
+            if (!defaultConfig) {
+                issues.push({
+                    level: "error",
+                    area: "config.json",
+                    message: "Missing public.default configuration block",
+                    fix: "Add a public.default object with commerce endpoints",
+                });
+            }
+            else {
+                if (!defaultConfig["commerce-endpoint"]) {
+                    issues.push({
+                        level: "error",
+                        area: "config.json",
+                        message: "Missing commerce-endpoint — catalog service GraphQL endpoint",
+                        fix: 'Add "commerce-endpoint" pointing to your catalog service GraphQL URL',
+                    });
+                }
+                if (!defaultConfig["commerce-core-endpoint"]) {
+                    issues.push({
+                        level: "warning",
+                        area: "config.json",
+                        message: "Missing commerce-core-endpoint — core Magento GraphQL endpoint",
+                        fix: 'Add "commerce-core-endpoint" pointing to your core GraphQL URL',
+                    });
+                }
+                if (!defaultConfig.headers?.cs) {
+                    issues.push({
+                        level: "warning",
+                        area: "config.json",
+                        message: "Missing catalog service headers (headers.cs)",
+                        fix: "Add headers.cs with required keys like Magento-Store-Code or AC-View-ID",
+                    });
+                }
+                if (!defaultConfig.analytics) {
+                    issues.push({
+                        level: "info",
+                        area: "config.json",
+                        message: "No analytics configuration found",
+                        fix: "Add analytics block for commerce event tracking (base-currency-code, environment, store-id, etc.)",
+                    });
+                }
+            }
+        }
+        const blocks = listBlocks(params.projectDir);
+        const commerceBlocks = blocks.filter((b) => {
+            if (!b.hasJs)
+                return false;
+            const js = readBlockFile(params.projectDir, b.name);
+            return (js !== null &&
+                extractImportsFromBlock(js).dropinImports.some((p) => p.includes("@dropins/storefront-")));
+        });
+        const blocksWithoutCss = commerceBlocks.filter((b) => !b.hasCss);
+        const blocksWithoutJs = blocks.filter((b) => !b.hasJs && (b.hasCss || b.name.startsWith("commerce-")));
+        if (blocksWithoutJs.length > 0) {
+            issues.push({
+                level: "warning",
+                area: "blocks",
+                message: `Blocks missing JS files: ${blocksWithoutJs.map((b) => b.name).join(", ")}`,
+                fix: "Each block directory should have a matching JS file (e.g., product-details/product-details.js)",
+            });
+        }
+        if (blocksWithoutCss.length > 0) {
+            issues.push({
+                level: "info",
+                area: "blocks",
+                message: `Dropin blocks missing CSS files: ${blocksWithoutCss.map((b) => b.name).join(", ")}`,
+                fix: "Consider adding CSS files for custom styling",
+            });
+        }
+        const initializers = listInitializers(params.projectDir);
+        if (initializers.length === 0 && commerceBlocks.length > 0) {
+            issues.push({
+                level: "warning",
+                area: "initializers",
+                message: "Dropin blocks exist but no dropin initializers found",
+                fix: "Create initializer files in scripts/initializers/ for each dropin (e.g., cart.js, checkout.js)",
+            });
+        }
+        issues.push(...checkDropinFileIntegrity(params.projectDir));
+        const errors = issues.filter((i) => i.level === "error");
+        const warnings = issues.filter((i) => i.level === "warning");
+        const infos = issues.filter((i) => i.level === "info");
+        const statusMessage = errors.length > 0
+            ? `Configuration has ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info(s)`
+            : warnings.length > 0
+                ? `Configuration has ${warnings.length} warning(s) and ${infos.length} info(s)`
+                : "Configuration looks good";
+        return formatSuccessResponse(statusMessage, {
+            valid: errors.length === 0,
+            summary: {
+                errors: errors.length,
+                warnings: warnings.length,
+                info: infos.length,
+            },
+            issues,
+        });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "checking configuration");
+    }
+}

package/dist/operations/explain-event-flow.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const ExplainEventFlowSchema: z.ZodObject<{
+    eventName: z.ZodString;
+    dropin: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    eventName: string;
+    dropin?: string | undefined;
+}, {
+    eventName: string;
+    dropin?: string | undefined;
+}>;
+export declare function explainEventFlow(params: z.infer<typeof ExplainEventFlowSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/explain-event-flow.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getEventCatalog } from "../common/registry-loader.js";
+import { sanitizeForComment } from "../common/sanitize.js";
+export const ExplainEventFlowSchema = z.object({
+    eventName: z
+        .string()
+        .describe('Exact or partial event name to look up (e.g. "cart/data", "cart", "order/placed"). Prefix matching is supported: "cart" matches all cart/* events.'),
+    dropin: z
+        .string()
+        .optional()
+        .describe('Filter results to events emitted or consumed by a specific dropin (e.g. "storefront-cart").'),
+});
+const RESERVED_VAR_NAMES = new Set([
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "symbol",
+    "bigint",
+    "null",
+    "undefined",
+    "void",
+    "any",
+    "never",
+    "unknown",
+]);
+function payloadVarName(payloadType) {
+    if (!payloadType)
+        return "payload";
+    if (payloadType.includes("{"))
+        return "data";
+    const stripped = payloadType.replace(/\[\]$/, "").replace(/\s+/g, "");
+    if (stripped.endsWith("Model")) {
+        return stripped.replace("Model", "").toLowerCase() || "data";
+    }
+    const candidate = stripped.toLowerCase().replace(/[^a-z]/g, "") || "payload";
+    return RESERVED_VAR_NAMES.has(candidate) ? "payload" : candidate;
+}
+function refLabel(ref) {
+    return ref.dropin.startsWith("boilerplate/")
+        ? ref.dropin.replace("boilerplate/", "block:")
+        : ref.dropin;
+}
+function uniqueLabels(refs) {
+    return [...new Set(refs.map(refLabel))];
+}
+function flowDirection(emittedBy, consumedBy) {
+    const isDropin = (r) => !r.dropin.startsWith("boilerplate/");
+    const emitDropin = emittedBy.some(isDropin);
+    const consumeDropin = consumedBy.some(isDropin);
+    const emitBlock = emittedBy.some((r) => !isDropin(r));
+    const consumeBlock = consumedBy.some((r) => !isDropin(r));
+    if (emittedBy.length === 0 && consumedBy.length === 0)
+        return "unknown";
+    if (emittedBy.length === 0)
+        return "consumed-only";
+    if (consumedBy.length === 0)
+        return "emitted-only";
+    if (emitDropin && consumeDropin && consumeBlock)
+        return "dropin-to-many";
+    if (emitDropin && consumeDropin)
+        return "dropin-to-dropin";
+    if (emitDropin && consumeBlock)
+        return "dropin-to-block";
+    if (emitBlock && consumeDropin)
+        return "block-to-dropin";
+    return "block-to-block";
+}
+function buildFlowSummary(name, emittedBy, consumedBy) {
+    const emitterLabels = emittedBy.length > 0
+        ? uniqueLabels(emittedBy).join(", ")
+        : "unknown emitter";
+    const consumerLabels = consumedBy.length > 0
+        ? uniqueLabels(consumedBy).join(", ")
+        : "no known consumers";
+    return `${name}: emitted by ${emitterLabels} -> consumed by ${consumerLabels}`;
+}
+function buildListenCode(event) {
+    const varName = payloadVarName(event.payloadType);
+    const payloadComment = event.payloadType
+        ? `  // Payload type: ${sanitizeForComment(event.payloadType)}\n`
+        : "";
+    const descComment = event.description
+        ? `  // ${sanitizeForComment(event.description)}\n`
+        : "";
+    return `import { events } from '@dropins/tools/event-bus.js';
+
+events.on('${event.name}', (${varName}) => {
+${payloadComment}${descComment}
+  // Handle the event here
+  console.log('DEBUG ${event.name}:', ${varName});
+});`;
+}
+function buildEmitCode(event) {
+    if (event.emittedBy.length === 0)
+        return null;
+    if (!event.payloadType) {
+        return `import { events } from '@dropins/tools/event-bus.js';
+
+events.emit('${event.name}');`;
+    }
+    const varName = payloadVarName(event.payloadType);
+    return `import { events } from '@dropins/tools/event-bus.js';
+
+const ${varName} = { /* ${event.payloadType} */ };
+events.emit('${event.name}', ${varName});`;
+}
+function tieBreakScore(event) {
+    let score = 0;
+    if (event.emittedBy.length > 0)
+        score += 2;
+    if (event.consumedBy.length > 0)
+        score += 2;
+    if (event.payloadType)
+        score += 1;
+    if (event.description)
+        score += 1;
+    score -= event.name.length * 0.01;
+    return score;
+}
+function matchEvents(events, query, dropinFilter, maxResults) {
+    const lowerQuery = query.toLowerCase().trim();
+    const byTier = {
+        exact: [],
+        prefix: [],
+        substring: [],
+    };
+    for (const event of events) {
+        const lowerName = event.name.toLowerCase();
+        if (dropinFilter) {
+            const involvedDropins = [
+                ...event.emittedBy.map((r) => r.dropin),
+                ...event.consumedBy.map((r) => r.dropin),
+            ];
+            if (!involvedDropins.includes(dropinFilter))
+                continue;
+        }
+        if (lowerName === lowerQuery) {
+            byTier.exact.push(event);
+        }
+        else if (lowerName.startsWith(lowerQuery + "/")) {
+            byTier.prefix.push(event);
+        }
+        else if (lowerName.includes(lowerQuery)) {
+            byTier.substring.push(event);
+        }
+    }
+    const sortByScore = (a, b) => tieBreakScore(b) - tieBreakScore(a);
+    const orderedTiers = [
+        [byTier.exact.sort(sortByScore), "exact"],
+        [byTier.prefix.sort(sortByScore), "prefix"],
+        [byTier.substring.sort(sortByScore), "substring"],
+    ];
+    const results = [];
+    for (const [bucket, tier] of orderedTiers) {
+        for (const event of bucket) {
+            if (results.length >= maxResults)
+                break;
+            const emittedBy = [
+                ...new Map((event.emittedBy ?? []).map((r) => [`${r.dropin}|${r.file}`, r])).values(),
+            ];
+            const consumedBy = [
+                ...new Map((event.consumedBy ?? []).map((r) => [`${r.dropin}|${r.file}`, r])).values(),
+            ];
+            results.push({
+                name: event.name,
+                matchTier: tier,
+                payloadType: event.payloadType || "(unknown)",
+                description: event.description || "(no description)",
+                emittedBy,
+                consumedBy,
+                direction: flowDirection(emittedBy, consumedBy),
+                flowSummary: buildFlowSummary(event.name, emittedBy, consumedBy),
+                listenCode: buildListenCode(event),
+                emitCode: buildEmitCode(event),
+            });
+        }
+        if (results.length >= maxResults)
+            break;
+    }
+    return results;
+}
+export async function explainEventFlow(params) {
+    try {
+        const catalog = getEventCatalog();
+        const allEvents = catalog.events ?? [];
+        const matched = matchEvents(allEvents, params.eventName, params.dropin, 10);
+        if (matched.length === 0) {
+            const namespaces = [
+                ...new Set(allEvents.map((e) => e.name.split("/")[0]).filter(Boolean)),
+            ].sort();
+            return formatSuccessResponse(`No events found matching "${params.eventName}"`, {
+                searched: params.eventName,
+                dropinFilter: params.dropin ?? null,
+                hint: `Use list_events to browse all events. Known namespaces: ${namespaces.join(", ")}`,
+            });
+        }
+        const tierCounts = matched.reduce((acc, e) => {
+            acc[e.matchTier] = (acc[e.matchTier] ?? 0) + 1;
+            return acc;
+        }, {});
+        const summary = matched.length === 1
+            ? `Found 1 event matching "${params.eventName}"`
+            : `Found ${matched.length} events matching "${params.eventName}" (${Object.entries(tierCounts)
+                .map(([t, c]) => `${c} ${t}`)
+                .join(", ")})`;
+        return formatSuccessResponse(summary, {
+            query: params.eventName,
+            dropinFilter: params.dropin ?? null,
+            totalMatched: matched.length,
+            events: matched,
+        });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "explaining event flow");
+    }
+}

package/dist/operations/get-upgrade-diff.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const GetUpgradeDiffSchema: z.ZodObject<{
+    projectDir: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectDir: string;
+}, {
+    projectDir: string;
+}>;
+export declare function getUpgradeDiff(params: z.infer<typeof GetUpgradeDiffSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/get-upgrade-diff.js

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getContainerRegistry, getApiFunctionRegistry, } from "../common/registry-loader.js";
+import { projectDirGuard, readPackageJson, extractDropinDependencies, listBlocks, readBlockFile, extractImportsFromBlock, } from "../common/project-reader.js";
+export const GetUpgradeDiffSchema = z.object({
+    projectDir: z
+        .string()
+        .describe("Absolute path to the merchant storefront project root"),
+});
+function parseVersion(versionStr) {
+    return versionStr.replace(/^[~^>=<]+/, "");
+}
+function compareVersions(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na !== nb)
+            return na - nb;
+    }
+    return 0;
+}
+export async function getUpgradeDiff(params) {
+    try {
+        const guard = projectDirGuard(params.projectDir);
+        if (guard)
+            return guard;
+        const pkg = readPackageJson(params.projectDir);
+        if (!pkg) {
+            return formatSuccessResponse("No package.json found", {
+                error: "Cannot analyze versions without package.json",
+            });
+        }
+        const dropinDeps = extractDropinDependencies(pkg);
+        const containerRegistry = getContainerRegistry();
+        const apiRegistry = getApiFunctionRegistry();
+        const blocks = listBlocks(params.projectDir);
+        const blockUsage = {};
+        for (const block of blocks) {
+            const content = readBlockFile(params.projectDir, block.name);
+            if (!content)
+                continue;
+            const imports = extractImportsFromBlock(content);
+            const dropins = [];
+            const scopedContainers = [];
+            for (const imp of imports.dropinImports) {
+                const dropinMatch = imp.match(/@dropins\/(storefront-[^/]+)/);
+                if (!dropinMatch)
+                    continue;
+                const d = dropinMatch[1];
+                if (!dropins.includes(d))
+                    dropins.push(d);
+                if (imp.includes("/containers/")) {
+                    const name = imp.split("/containers/").pop()?.replace(".js", "");
+                    if (name)
+                        scopedContainers.push({ dropin: d, name });
+                }
+            }
+            blockUsage[block.name] = {
+                scopedContainers,
+                dropins,
+            };
+        }
+        const diffs = [];
+        for (const dep of dropinDeps) {
+            const dropinName = dep.name.replace("@dropins/", "");
+            if (dropinName === "tools" || dropinName === "build-tools")
+                continue;
+            const containerData = containerRegistry.dropins[dropinName];
+            const apiData = apiRegistry.dropins?.[dropinName];
+            if (!containerData)
+                continue;
+            const installedVersion = parseVersion(dep.version);
+            const registryVersion = containerData.version ?? "unknown";
+            const blocksUsingDropin = Object.entries(blockUsage)
+                .filter(([_, usage]) => usage.dropins.includes(dropinName))
+                .map(([blockName]) => blockName);
+            const usedContainerNames = Object.values(blockUsage)
+                .flatMap((usage) => usage.scopedContainers)
+                .filter((sc) => sc.dropin === dropinName)
+                .map((sc) => sc.name);
+            const containers = containerData.containers.map((c) => {
+                return {
+                    name: c.name,
+                    availableSlots: c.slotNames ?? [],
+                    usedInBlocks: Object.entries(blockUsage)
+                        .filter(([_, usage]) => usage.scopedContainers.some((sc) => sc.dropin === dropinName && sc.name === c.name))
+                        .map(([blockName]) => blockName),
+                };
+            });
+            const unusedContainers = containerData.containers
+                .map((c) => c.name)
+                .filter((name) => !usedContainerNames.includes(name));
+            const apiFunctions = (apiData?.functions ?? []).map((f) => ({
+                name: f.name,
+                signature: f.signature,
+            }));
+            const migrationNotes = [];
+            if (installedVersion !== registryVersion &&
+                registryVersion !== "unknown") {
+                const installedMajor = parseInt(installedVersion.split(".")[0], 10);
+                const registryMajor = parseInt(registryVersion.split(".")[0], 10);
+                if (registryMajor > installedMajor) {
+                    migrationNotes.push(`Major version upgrade available (${installedVersion} → ${registryVersion}). Check for breaking changes.`);
+                }
+                else if (compareVersions(registryVersion, installedVersion) > 0) {
+                    migrationNotes.push(`Minor/patch update available (${installedVersion} → ${registryVersion}).`);
+                }
+            }
+            if (unusedContainers.length > 0) {
+                migrationNotes.push(`${unusedContainers.length} container(s) available but not used: ${unusedContainers.join(", ")}`);
+            }
+            if (blocksUsingDropin.length === 0) {
+                migrationNotes.push("Dropin is installed but not used in any block");
+            }
+            diffs.push({
+                dropin: dropinName,
+                installedVersion,
+                registryVersion,
+                versionMatch: installedVersion === registryVersion,
+                blocksUsingDropin,
+                containers,
+                unusedContainers,
+                apiFunctions,
+                migrationNotes,
+            });
+        }
+        const outdatedCount = diffs.filter((d) => !d.versionMatch).length;
+        const totalNotes = diffs.reduce((sum, d) => sum + d.migrationNotes.length, 0);
+        return formatSuccessResponse(`Analyzed ${diffs.length} dropins: ${outdatedCount} version mismatch(es), ${totalNotes} migration note(s)`, {
+            summary: {
+                totalDropins: diffs.length,
+                outdated: outdatedCount,
+                upToDate: diffs.length - outdatedCount,
+                totalMigrationNotes: totalNotes,
+            },
+            dropins: diffs,
+        });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "generating upgrade diff");
+    }
+}

package/dist/operations/list-api-functions.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const ListApiFunctionsSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dropin?: string | undefined;
+}, {
+    dropin?: string | undefined;
+}>;
+export declare function listApiFunctions(params: z.infer<typeof ListApiFunctionsSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;