@zapier/zapier-sdk-cli 0.34.11 → 0.35.0

package/dist/index.cjs

@@ -371,9 +371,10 @@ var loginPlugin = ({
     const user = await cliLogin.getLoggedInUser();
     context.eventEmission.emit(
       "platform.sdk.ApplicationLifecycleEvent",
-      zapierSdk.buildApplicationLifecycleEvent({
-        lifecycle_event_type: "login_success"
-      })
+      zapierSdk.buildApplicationLifecycleEvent(
+        { lifecycle_event_type: "login_success" },
+        { customuser_id: user.customUserId, account_id: user.accountId }
+      )
     );
     console.log(`\u2705 Successfully logged in as ${user.email}`);
   };
@@ -383,7 +384,8 @@ var loginPlugin = ({
       meta: {
         login: {
           categories: ["account"],
-          inputSchema: LoginSchema
+          inputSchema: LoginSchema,
+          supportsJsonOutput: false
         }
       }
     }
@@ -402,7 +404,8 @@ var logoutPlugin = () => ({
     meta: {
       logout: {
         categories: ["account"],
-        inputSchema: LogoutSchema
+        inputSchema: LogoutSchema,
+        supportsJsonOutput: false
       }
     }
   }
@@ -2489,7 +2492,8 @@ var initPlugin = () => {
       meta: {
         init: {
           categories: ["utility"],
-          inputSchema: InitSchema
+          inputSchema: InitSchema,
+          supportsJsonOutput: false
         }
       }
     }
@@ -2507,7 +2511,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.34.11"};
+  version: "0.35.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/index.mjs

@@ -338,9 +338,10 @@ var loginPlugin = ({
     const user = await getLoggedInUser();
     context.eventEmission.emit(
       "platform.sdk.ApplicationLifecycleEvent",
-      buildApplicationLifecycleEvent({
-        lifecycle_event_type: "login_success"
-      })
+      buildApplicationLifecycleEvent(
+        { lifecycle_event_type: "login_success" },
+        { customuser_id: user.customUserId, account_id: user.accountId }
+      )
     );
     console.log(`\u2705 Successfully logged in as ${user.email}`);
   };
@@ -350,7 +351,8 @@ var loginPlugin = ({
       meta: {
         login: {
           categories: ["account"],
-          inputSchema: LoginSchema
+          inputSchema: LoginSchema,
+          supportsJsonOutput: false
         }
       }
     }
@@ -369,7 +371,8 @@ var logoutPlugin = () => ({
     meta: {
       logout: {
         categories: ["account"],
-        inputSchema: LogoutSchema
+        inputSchema: LogoutSchema,
+        supportsJsonOutput: false
       }
     }
   }
@@ -2456,7 +2459,8 @@ var initPlugin = () => {
       meta: {
         init: {
           categories: ["utility"],
-          inputSchema: InitSchema
+          inputSchema: InitSchema,
+          supportsJsonOutput: false
         }
       }
     }
@@ -2474,7 +2478,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.34.11"};
+  version: "0.35.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.34.11",
+    "version": "0.35.0",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",

package/dist/src/plugins/init/index.js

@@ -54,6 +54,7 @@ export const initPlugin = () => {
                 init: {
                     categories: ["utility"],
                     inputSchema: InitSchema,
+                    supportsJsonOutput: false,
                 },
             },
         },

package/dist/src/plugins/login/index.js

@@ -30,9 +30,7 @@ export const loginPlugin = ({ context, }) => {
             credentials: pkceCredentials,
         });
         const user = await getLoggedInUser();
-        context.eventEmission.emit("platform.sdk.ApplicationLifecycleEvent", buildApplicationLifecycleEvent({
-            lifecycle_event_type: "login_success",
-        }));
+        context.eventEmission.emit("platform.sdk.ApplicationLifecycleEvent", buildApplicationLifecycleEvent({ lifecycle_event_type: "login_success" }, { customuser_id: user.customUserId, account_id: user.accountId }));
         console.log(`✅ Successfully logged in as ${user.email}`);
     };
     return {
@@ -42,6 +40,7 @@ export const loginPlugin = ({ context, }) => {
                 login: {
                     categories: ["account"],
                     inputSchema: LoginSchema,
+                    supportsJsonOutput: false,
                 },
             },
         },

package/dist/src/plugins/logout/index.js

@@ -12,6 +12,7 @@ export const logoutPlugin = () => ({
             logout: {
                 categories: ["account"],
                 inputSchema: LogoutSchema,
+                supportsJsonOutput: false,
             },
         },
     },

package/dist/src/utils/cli-generator.js

@@ -1,13 +1,15 @@
 import { z } from "zod";
-import { isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
+import { isPositional } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
-import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
 import chalk from "chalk";
 import inquirer from "inquirer";
-import { ZapierCliError, ZapierCliExitError } from "./errors";
+import { ZapierCliError, ZapierCliExitError, ZapierCliMissingParametersError, ZapierCliValidationError, } from "./errors";
 import { SHARED_COMMAND_CLI_OPTIONS } from "./cli-options";
 import { buildCliCommandExecutedEvent } from "../telemetry/builders";
+import { createJsonRenderer, createInteractiveRenderer } from "./cli-renderer";
+import { toKebabCase } from "./string-utils";
 const CLI_COMMAND_EXECUTED_EVENT_SUBJECT = "platform.sdk.CliCommandExecutedEvent";
+const PAGINATION_PARAM_NAMES = new Set(["maxItems", "pageSize", "cursor"]);
 // Flags whose values may contain secrets and must not appear in telemetry
 const SENSITIVE_FLAGS = [
     "--credentials",
@@ -41,6 +43,60 @@ export function sanitizeCliArguments(args) {
     }
     return sanitized;
 }
+function getNormalizedResult(result, { isListCommand }) {
+    if (result instanceof Response) {
+        return { kind: "response", value: result };
+    }
+    if (isListCommand) {
+        const sdkResult = result;
+        if (!Array.isArray(sdkResult?.data)) {
+            throw new Error(`List command returned unexpected shape (expected { data: [] }): ${JSON.stringify(result).slice(0, 200)}`);
+        }
+        return {
+            kind: "list",
+            data: sdkResult.data,
+            nextCursor: sdkResult.nextCursor,
+        };
+    }
+    const sdkResult = result;
+    return {
+        kind: "item",
+        value: result !== null && typeof result === "object" && "data" in result
+            ? sdkResult.data
+            : result,
+    };
+}
+function hasItems(sdkResult) {
+    return (sdkResult != null &&
+        typeof sdkResult.items === "function");
+}
+function hasPages(sdkResult) {
+    return (sdkResult != null &&
+        typeof sdkResult[Symbol.asyncIterator] === "function");
+}
+async function* toItemsStream(sdkResult) {
+    if (hasItems(sdkResult)) {
+        yield* sdkResult.items();
+        return;
+    }
+    if (hasPages(sdkResult)) {
+        for await (const page of sdkResult) {
+            yield* page.data ?? [];
+        }
+        return;
+    }
+    throw new ZapierCliExitError(`SDK method returned a value that is not async-iterable. Got: ${typeof sdkResult}. ` +
+        `List methods must return an AsyncIterable or an object with an items() method.`, 1);
+}
+async function collectItemsFromResult({ sdkResult, maxItems, }) {
+    const items = [];
+    for await (const item of toItemsStream(sdkResult)) {
+        items.push(item);
+        if (maxItems !== undefined && items.length >= maxItems)
+            break;
+    }
+    return maxItems !== undefined ? items.slice(0, maxItems) : items;
+}
 const CONFIRM_MESSAGES = {
     "create-secret": {
         messageBefore: "You are about to create a sensitive secret that will be displayed as plain text.\n" +
@@ -77,6 +133,13 @@ function emitDeprecationWarning({ cliCommandName, deprecation, }) {
     console.warn(chalk.yellow(`   ${deprecation.message}`));
     console.warn();
 }
+function resolveOutputMode({ isListCommand, hasPaginationParams, hasUserSpecifiedMaxItems, }) {
+    if (!isListCommand || !hasPaginationParams)
+        return "single";
+    if (hasUserSpecifiedMaxItems)
+        return "collect";
+    return "paginate";
+}
 // ============================================================================
 // Schema Analysis
 // ============================================================================
@@ -247,13 +310,6 @@ function reconstructPositionalArgs(inputParameters, flatParams) {
 // ============================================================================
 // CLI Structure Derivation - Purely Generic
 // ============================================================================
-/**
- * Convert camelCase to kebab-case
- * e.g., listApps -> list-apps, generateTypes -> generate-types
- */
-function toKebabCase(str) {
-    return str.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
 /**
  * Convert SDK method name directly to CLI command
  * e.g., listApps -> list-apps, getApp -> get-app, generateTypes -> generate-types
@@ -348,6 +404,13 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
         let success = true;
         let errorMessage = null;
         let resolvedParams = {};
+        // interactiveMode is true by default; --json disables it
+        const commandObj = args[args.length - 1];
+        const options = commandObj.opts();
+        const interactiveMode = !options.json;
+        const renderer = interactiveMode
+            ? createInteractiveRenderer()
+            : createJsonRenderer();
         try {
             // The last argument is always the command object with parsed options
             const commandObj = args[args.length - 1];
@@ -358,24 +421,24 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
             });
             // Check if this is a list command for pagination
             const isListCommand = functionInfo.type === "list";
-            const hasPaginationParams = parameters.some((p) => p.name === "maxItems" || p.name === "pageSize");
+            const hasPaginationParams = parameters.some((p) => PAGINATION_PARAM_NAMES.has(p.name));
             const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== undefined;
-            const shouldUseJson = options.json;
-            // Convert CLI args to SDK method parameters
+            const outputMode = resolveOutputMode({
+                isListCommand,
+                hasPaginationParams,
+                hasUserSpecifiedMaxItems,
+            });
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
-            // Resolve missing parameters interactively using schema metadata
-            // (only available for inputSchema-based functions)
             if (schema && !usesInputParameters) {
                 const resolver = new SchemaParameterResolver();
-                resolvedParams = (await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name));
+                resolvedParams = (await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name, { interactiveMode }));
             }
             else {
                 resolvedParams = rawParams;
             }
-            // Check for confirmation before executing (skip for --json mode)
             const confirm = functionInfo.confirm;
             let confirmMessageAfter;
-            if (confirm && !shouldUseJson) {
+            if (confirm && interactiveMode) {
                 const confirmResult = await promptConfirm(confirm);
                 if (!confirmResult.confirmed) {
                     console.log(chalk.yellow("Operation cancelled."));
@@ -383,111 +446,82 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
                 }
                 confirmMessageAfter = confirmResult.messageAfter;
             }
-            // Handle paginated list commands with async iteration
-            if (isListCommand &&
-                hasPaginationParams &&
-                !shouldUseJson &&
-                !hasUserSpecifiedMaxItems) {
-                // Get the async iterable directly from the SDK method call (don't await it! that breaks the next page behavior)
-                const sdkObj = sdk;
-                const sdkIterable = sdkObj[functionInfo.name](resolvedParams);
-                await handlePaginatedListWithAsyncIteration(functionInfo.name, sdkIterable, functionInfo);
-            }
-            else {
-                // Special handling for commands that write to files
-                const hasOutputFile = resolvedParams.output;
-                if (hasOutputFile) {
-                    const sdkObj = sdk;
-                    await sdkObj[functionInfo.name](resolvedParams);
-                    console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
-                    console.log(chalk.gray(`Output written to: ${hasOutputFile}`));
-                    return;
-                }
-                // Invoke SDK method — reconstruct positional args for inputParameters functions
-                let result;
-                if (usesInputParameters) {
-                    const positionalArgs = reconstructPositionalArgs(functionInfo.inputParameters, resolvedParams);
-                    const sdkObj = sdk;
-                    result = await sdkObj[functionInfo.name](...positionalArgs);
+            const sdkMethod = sdk[functionInfo.name];
+            switch (outputMode) {
+                case "paginate": {
+                    const source = sdkMethod(resolvedParams);
+                    await renderer.renderPaginatedList(source, functionInfo);
+                    break;
                 }
-                else {
-                    const sdkObj = sdk;
-                    result = await sdkObj[functionInfo.name](resolvedParams);
+                case "collect": {
+                    const maxItems = resolvedParams.maxItems;
+                    const sdkResult = sdkMethod({ ...resolvedParams, maxItems });
+                    const allItems = await collectItemsFromResult({
+                        sdkResult,
+                        maxItems,
+                    });
+                    renderer.renderCollectedList(allItems, {
+                        maxItems,
+                        userSpecifiedMaxItems: hasUserSpecifiedMaxItems,
+                        functionInfo,
+                    });
+                    break;
                 }
-                // Handle Response objects by wrapping in a structured envelope
-                if (result instanceof Response) {
-                    const response = result;
-                    let body;
-                    // Read as text first to preserve body for error messages
-                    const text = await response
-                        .text()
-                        .catch(() => "[unable to read body]");
-                    try {
-                        body = JSON.parse(text);
+                case "single": {
+                    const callSdkMethod = () => {
+                        if (usesInputParameters) {
+                            const positionalArgs = reconstructPositionalArgs(functionInfo.inputParameters, resolvedParams);
+                            return sdkMethod(...positionalArgs);
+                        }
+                        return sdkMethod(resolvedParams);
+                    };
+                    const outputFile = resolvedParams.output;
+                    if (outputFile) {
+                        await callSdkMethod();
+                        renderer.renderItem(null, {
+                            outputFile,
+                            commandName: cliCommandName,
+                        });
+                        break;
                     }
-                    catch {
-                        throw new Error(`Failed to parse response as JSON (status: ${response.status}). Body: ${text.slice(0, 500)}`);
+                    const result = await callSdkMethod();
+                    const normalizedResult = getNormalizedResult(result, {
+                        isListCommand,
+                    });
+                    if (normalizedResult.kind === "response") {
+                        await renderer.renderResponse(normalizedResult.value);
                     }
-                    result = {
-                        statusCode: response.status,
-                        headers: Object.fromEntries(response.headers.entries()),
-                        body,
-                    };
-                }
-                const items = result?.data
-                    ? result.data
-                    : result;
-                if (shouldUseJson) {
-                    console.log(JSON.stringify(items, null, 2));
-                }
-                else if (isListCommand) {
-                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, functionInfo);
-                }
-                else {
-                    formatJsonOutput(items);
-                }
-                // Show message after operation completes
-                if (confirmMessageAfter) {
-                    console.log(chalk.yellow(`\n${confirmMessageAfter}`));
+                    else if (normalizedResult.kind === "list") {
+                        renderer.renderCollectedList(normalizedResult.data, {
+                            maxItems: resolvedParams.maxItems,
+                            userSpecifiedMaxItems: hasUserSpecifiedMaxItems,
+                            functionInfo,
+                        });
+                    }
+                    else {
+                        renderer.renderItem(normalizedResult.value);
+                    }
+                    if (confirmMessageAfter) {
+                        console.log(chalk.yellow(`\n${confirmMessageAfter}`));
+                    }
+                    break;
                 }
             }
         }
         catch (error) {
             success = false;
             errorMessage = error instanceof Error ? error.message : String(error);
-            // Handle Zod validation errors more gracefully
-            if (error instanceof Error && error.message.includes('"code"')) {
-                try {
-                    const validationErrors = JSON.parse(error.message);
-                    console.error(chalk.red("❌ Validation Error:"));
-                    validationErrors.forEach((err) => {
-                        const errorObj = err;
-                        const field = errorObj?.path?.join(".") || "unknown";
-                        console.error(chalk.yellow(`  • ${field}: ${errorObj?.message || "Unknown error"}`));
-                    });
-                    console.error("\n" + chalk.dim(`Use --help to see available options`));
-                    throw new ZapierCliExitError("Validation failed", 1);
-                }
-                catch {
-                    console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
-                    throw new ZapierCliExitError(error instanceof Error ? error.message : String(error), 1);
-                }
+            if (error instanceof ZapierCliMissingParametersError) {
+                renderer.renderError(error);
+            }
+            else if (error instanceof ZapierCliValidationError) {
+                renderer.renderError(error);
             }
             else if (error instanceof ZapierCliError) {
-                // Re-throw all CLI errors as-is
                 throw error;
             }
-            else if (error instanceof ZapierError) {
-                // Handle SDK errors with clean, user-friendly messages using our formatter
-                const formattedMessage = formatErrorMessage(error);
-                console.error(chalk.red("❌ Error:"), formattedMessage);
-                throw new ZapierCliExitError(formattedMessage, 1);
-            }
             else {
-                // Handle other errors
-                const msg = error instanceof Error ? error.message : "Unknown error";
-                console.error(chalk.red("❌ Error:"), msg);
-                throw new ZapierCliExitError(msg, 1);
+                renderer.renderError(error);
             }
         }
         finally {
@@ -522,6 +556,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
         handler,
         hidden: functionInfo.categories?.includes("deprecated") ?? false,
         aliases: functionInfo.aliases,
+        supportsJsonOutput: functionInfo.supportsJsonOutput,
     };
 }
 // Collect function for repeatable options (e.g., -d foo -d bar → ['foo', 'bar'])
@@ -537,8 +572,7 @@ function addCommand(program, commandName, config) {
     let hasPositionalArray = false;
     // Add parameters to command
     config.parameters.forEach((param) => {
-        // Convert camelCase to kebab-case for CLI display
-        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const kebabName = toKebabCase(param.name);
         if (param.hasResolver && param.required) {
             // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
             command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
@@ -587,12 +621,14 @@ function addCommand(program, commandName, config) {
             }
         }
     });
-    // Add shared command options (if not already included)
+    // Add shared command options (if not already included or excluded by interactive mode)
     const paramNames = new Set(config.parameters.map((p) => p.name));
     SHARED_COMMAND_CLI_OPTIONS.forEach((opt) => {
-        if (!paramNames.has(opt.name)) {
-            command.option(opt.flag, opt.description);
-        }
+        if (paramNames.has(opt.name))
+            return;
+        if (config.supportsJsonOutput === false && opt.name === "json")
+            return;
+        command.option(opt.flag, opt.description);
     });
     command.action(config.handler);
 }
@@ -669,144 +705,3 @@ function convertValue(value, type) {
             return value;
     }
 }
-// ============================================================================
-// Pagination Handlers
-// ============================================================================
-async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, functionInfo) {
-    const itemName = getItemNameFromMethod(functionInfo);
-    let totalShown = 0;
-    let pageCount = 0;
-    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
-    try {
-        // Use async iteration to go through pages
-        for await (const page of sdkResult) {
-            const items = page.data || page;
-            pageCount++;
-            if (!Array.isArray(items)) {
-                console.log(chalk.yellow(`No ${itemName} found.`));
-                return;
-            }
-            if (items.length === 0 && pageCount === 1) {
-                console.log(chalk.yellow(`No ${itemName} found.`));
-                return;
-            }
-            if (items.length === 0) {
-                break; // No more items
-            }
-            // Clear screen for subsequent pages (not the first)
-            if (pageCount > 1) {
-                console.clear();
-                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
-            }
-            // Format and display items using function info
-            if (functionInfo && functionInfo.inputSchema) {
-                formatItemsFromSchema(functionInfo, items, totalShown);
-            }
-            else {
-                formatItemsGeneric(items, totalShown);
-            }
-            totalShown += items.length;
-            console.log(chalk.green(`\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`));
-            // Only prompt if there's a nextCursor (more pages available)
-            if (page.nextCursor) {
-                const { continueReading } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "continueReading",
-                        message: `Load next page?`,
-                        default: true,
-                    },
-                ]);
-                if (!continueReading) {
-                    break;
-                }
-            }
-            else {
-                // No more pages available, exit gracefully
-                break;
-            }
-        }
-        console.log(chalk.gray(`\n📄 Finished browsing ${itemName}`));
-    }
-    catch (error) {
-        // If the result is not async iterable, fall back to showing the first page
-        const items = sdkResult?.data || sdkResult;
-        if (Array.isArray(items)) {
-            if (items.length === 0) {
-                console.log(chalk.yellow(`No ${itemName} found.`));
-                return;
-            }
-            if (functionInfo && functionInfo.inputSchema) {
-                formatItemsFromSchema(functionInfo, items, 0);
-            }
-            else {
-                formatItemsGeneric(items, 0);
-            }
-            console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
-        }
-        else {
-            throw error;
-        }
-    }
-}
-function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, functionInfo) {
-    if (!Array.isArray(result)) {
-        if (useRawJson) {
-            console.log(JSON.stringify(result, null, 2));
-        }
-        else {
-            formatJsonOutput(result);
-        }
-        return;
-    }
-    if (useRawJson) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
-    if (result.length === 0) {
-        console.log(chalk.yellow(`No ${itemName} found.`));
-        return;
-    }
-    console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
-    // Use function info for formatting
-    if (functionInfo && functionInfo.inputSchema) {
-        formatItemsFromSchema(functionInfo, result);
-    }
-    else {
-        // Fallback to generic formatting
-        formatItemsGeneric(result);
-    }
-    // Show appropriate status message
-    if (userSpecifiedMaxItems && requestedMaxItems) {
-        console.log(chalk.gray(`\n📄 Showing up to ${requestedMaxItems} ${itemName} (--max-items ${requestedMaxItems})`));
-    }
-    else {
-        console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
-    }
-}
-function formatItemsGeneric(items, startingNumber = 0) {
-    // Fallback formatting for items without schema metadata
-    items.forEach((item, index) => {
-        const itemObj = item;
-        const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
-        console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`);
-        if (itemObj?.description) {
-            console.log(`   ${chalk.dim(String(itemObj.description))}`);
-        }
-        console.log();
-    });
-}
-// Generic helper functions that infer from schema description or method name
-function getItemNameFromMethod(functionInfo) {
-    if (functionInfo.itemType) {
-        return `${functionInfo.itemType} items`;
-    }
-    return "items";
-}
-function getListTitleFromMethod(methodName, functionInfo) {
-    if (functionInfo.itemType) {
-        return `Available ${functionInfo.itemType} items`;
-    }
-    return `${methodName} items`;
-}