@zapier/zapier-sdk-cli 0.19.0 → 0.21.0

package/dist/src/plugins/buildManifest/schemas.d.ts

@@ -1,44 +0,0 @@
-import { z } from "zod";
-import type { AppItem, Manifest } from "@zapier/zapier-sdk";
-export declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString>;
-    skipWrite: z.ZodOptional<z.ZodBoolean>;
-    configPath: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
-    onProgress?: (event: ManifestBuildProgressEvent) => void;
-};
-export type ManifestBuildProgressEvent = {
-    type: "apps_lookup_start";
-    count: number;
-} | {
-    type: "app_found";
-    app: AppItem;
-} | {
-    type: "apps_lookup_complete";
-    count: number;
-} | {
-    type: "app_processing_start";
-    appKey: string;
-    slug?: string;
-} | {
-    type: "manifest_entry_built";
-    appKey: string;
-    manifestKey: string;
-    version: string;
-} | {
-    type: "manifest_updated";
-    appKey: string;
-    manifestKey: string;
-    version: string;
-} | {
-    type: "app_processing_complete";
-    appKey: string;
-} | {
-    type: "app_processing_error";
-    appKey: string;
-    error: string;
-};
-export interface BuildManifestResult {
-    manifest?: Manifest;
-}

package/dist/src/plugins/buildManifest/schemas.js

@@ -1,17 +0,0 @@
-import { z } from "zod";
-export const BuildManifestSchema = z
-    .object({
-    appKeys: z
-        .array(z.string().min(1, "App key cannot be empty"))
-        .min(1, "At least one app key is required")
-        .describe("One or more app keys to build manifest entries for (e.g., 'slack', 'github', 'trello')"),
-    skipWrite: z
-        .boolean()
-        .optional()
-        .describe("If true, returns manifest entries without writing to disk. If false or omitted, writes to the manifest file."),
-    configPath: z
-        .string()
-        .optional()
-        .describe("Path to the manifest file. Only used when skipWrite is false or omitted."),
-})
-    .describe("Build manifest entries for apps - can optionally write to disk or just return JSON");

package/dist/src/plugins/bundleCode/index.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { BundleCodeSchema, type BundleCodeOptions } from "./schemas";
-export interface BundleCodePluginProvides {
-    bundleCode: (options: BundleCodeOptions) => Promise<string>;
-    context: {
-        meta: {
-            bundleCode: {
-                inputSchema: typeof BundleCodeSchema;
-            };
-        };
-    };
-}
-export declare const bundleCodePlugin: Plugin<{}, // requires no existing SDK methods
-{}, // requires no context
-BundleCodePluginProvides>;

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

@@ -1,80 +0,0 @@
-import { BundleCodeSchema } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { buildSync } from "esbuild";
-import * as fs from "fs";
-import * as path from "path";
-export const bundleCodePlugin = () => {
-    const bundleCodeWithSdk = createFunction(async function bundleCodeWithSdk(options) {
-        return await bundleCode(options);
-    }, BundleCodeSchema);
-    return {
-        bundleCode: bundleCodeWithSdk,
-        context: {
-            meta: {
-                bundleCode: {
-                    categories: ["utility"],
-                    inputSchema: BundleCodeSchema,
-                },
-            },
-        },
-    };
-};
-class ZapierBundleError extends Error {
-    constructor(message, details, originalError) {
-        super(message);
-        this.code = "ZAPIER_BUNDLE_ERROR";
-        this.name = "ZapierBundleError";
-        this.details = details;
-        this.originalError = originalError;
-    }
-}
-/**
- * Bundle TypeScript code into executable JavaScript (CLI version)
- */
-async function bundleCode(options) {
-    const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
-    // Resolve input path
-    const resolvedInput = path.resolve(process.cwd(), input);
-    try {
-        // Bundle with esbuild
-        const result = buildSync({
-            entryPoints: [resolvedInput],
-            bundle: true,
-            platform: "node",
-            target: target,
-            format: cjs ? "cjs" : "esm",
-            minify: minify,
-            write: false,
-            external: [], // Bundle everything
-            banner: {
-                js: "#!/usr/bin/env node",
-            },
-        });
-        if (result.errors.length > 0) {
-            const errorMessages = result.errors.map((e) => e.text);
-            throw new ZapierBundleError(`Bundle failed: ${errorMessages.join(", ")}`, errorMessages);
-        }
-        const bundledCode = result.outputFiles?.[0]?.text;
-        if (!bundledCode) {
-            throw new ZapierBundleError("No output generated");
-        }
-        let finalOutput = bundledCode;
-        if (returnString) {
-            // Output as quoted string for node -e using JSON.stringify
-            finalOutput = JSON.stringify(bundledCode);
-        }
-        // Write to file if output path specified
-        if (output) {
-            fs.mkdirSync(path.dirname(output), { recursive: true });
-            fs.writeFileSync(output, finalOutput, "utf8");
-        }
-        return finalOutput;
-    }
-    catch (error) {
-        // If it's already a ZapierBundleError, re-throw as-is
-        if (error instanceof ZapierBundleError) {
-            throw error;
-        }
-        throw new ZapierBundleError(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`, undefined, error instanceof Error ? error : undefined);
-    }
-}

package/dist/src/plugins/bundleCode/schemas.d.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-export declare const BundleCodeSchema: z.ZodObject<{
-    input: z.ZodString;
-    output: z.ZodOptional<z.ZodString>;
-    string: z.ZodOptional<z.ZodBoolean>;
-    minify: z.ZodOptional<z.ZodBoolean>;
-    target: z.ZodOptional<z.ZodString>;
-    cjs: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;

package/dist/src/plugins/bundleCode/schemas.js

@@ -1,19 +0,0 @@
-import { z } from "zod";
-import { OutputPropertySchema } from "@zapier/zapier-sdk";
-// Bundle code schema - mirrors the original from SDK but for CLI use
-export const BundleCodeSchema = z
-    .object({
-    input: z.string().min(1).describe("Input TypeScript file path to bundle"),
-    output: OutputPropertySchema.optional().describe("Output file path (defaults to input with .js extension)"),
-    string: z
-        .boolean()
-        .optional()
-        .describe("Return bundled code as string instead of writing to file"),
-    minify: z.boolean().optional().describe("Minify the bundled output"),
-    target: z.string().optional().describe("ECMAScript target version"),
-    cjs: z
-        .boolean()
-        .optional()
-        .describe("Output CommonJS format instead of ESM"),
-})
-    .describe("Bundle TypeScript code into executable JavaScript");

package/dist/src/plugins/generateAppTypes/index.d.ts

@@ -1,13 +0,0 @@
-import type { Plugin, GetSdkType, ListActionsPluginProvides, ListAppsPluginProvides, ListInputFieldsPluginProvides, ListAuthenticationsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
-import { GenerateAppTypesSchema, type GenerateAppTypesOptions, type GenerateAppTypesResult } from "./schemas";
-export interface GenerateAppTypesPluginProvides {
-    generateAppTypes: (options: GenerateAppTypesOptions) => Promise<GenerateAppTypesResult>;
-    context: {
-        meta: {
-            generateAppTypes: {
-                inputSchema: typeof GenerateAppTypesSchema;
-            };
-        };
-    };
-}
-export declare const generateAppTypesPlugin: Plugin<GetSdkType<ListAppsPluginProvides & ListActionsPluginProvides & ListInputFieldsPluginProvides & ListAuthenticationsPluginProvides & ManifestPluginProvides>, {}, GenerateAppTypesPluginProvides>;

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

@@ -1,157 +0,0 @@
-import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
-import { GenerateAppTypesSchema, } from "./schemas";
-import { AstTypeGenerator } from "../../generators/ast-generator";
-import { getManifestKey } from "../../utils/manifest-helpers";
-import { mkdir, writeFile } from "fs/promises";
-import { join, resolve } from "path";
-import { detectTypesOutputDirectory } from "../../utils/directory-detection";
-export const generateAppTypesPlugin = ({ sdk }) => {
-    const generateAppTypes = createFunction(async function generateAppTypes(options) {
-        const { appKeys, authenticationIds, skipWrite = false, typesOutputDirectory = await detectTypesOutputDirectory(), onProgress, } = options;
-        const resolvedTypesOutput = resolve(typesOutputDirectory);
-        const result = {
-            typeDefinitions: {},
-        };
-        // Get apps using listApps (which respects existing manifest for version locking)
-        onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
-        const appsIterator = sdk.listApps({ appKeys }).items();
-        const apps = [];
-        for await (const app of appsIterator) {
-            apps.push(app);
-            onProgress?.({ type: "app_found", app });
-        }
-        onProgress?.({ type: "apps_lookup_complete", count: apps.length });
-        if (apps.length === 0) {
-            return result;
-        }
-        // Fetch authentications if provided
-        const authentications = [];
-        if (authenticationIds && authenticationIds.length > 0) {
-            onProgress?.({
-                type: "authentications_lookup_start",
-                count: authenticationIds.length,
-            });
-            const authsIterator = sdk
-                .listAuthentications({ authenticationIds })
-                .items();
-            for await (const auth of authsIterator) {
-                authentications.push(auth);
-            }
-            onProgress?.({
-                type: "authentications_lookup_complete",
-                count: authentications.length,
-            });
-        }
-        // Ensure output directory exists if we're writing files
-        if (!skipWrite && resolvedTypesOutput) {
-            await mkdir(resolvedTypesOutput, { recursive: true });
-        }
-        // Initialize writtenFiles if we're writing to disk
-        if (!skipWrite) {
-            result.writtenFiles = {};
-        }
-        // Process each app
-        for (const app of apps) {
-            onProgress?.({
-                type: "app_processing_start",
-                appKey: app.key,
-                slug: app.slug,
-            });
-            try {
-                if (!app.version) {
-                    const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-                    onProgress?.({
-                        type: "app_processing_error",
-                        appKey: app.key,
-                        error: errorMessage,
-                    });
-                    throw new ZapierValidationError(errorMessage, {
-                        details: {
-                            appKey: app.key,
-                            implementationId: app.implementation_id,
-                        },
-                    });
-                }
-                // Find matching authentication for this app if authentications were provided
-                let authenticationId;
-                if (authentications.length > 0) {
-                    const matchingAuth = authentications.find((auth) => {
-                        return auth.app_key === app.key;
-                    });
-                    if (matchingAuth) {
-                        authenticationId = matchingAuth.id;
-                        onProgress?.({
-                            type: "authentication_matched",
-                            appKey: app.key,
-                            authenticationId: matchingAuth.id,
-                            authenticationTitle: matchingAuth.title || "",
-                        });
-                    }
-                    else {
-                        onProgress?.({
-                            type: "authentication_not_matched",
-                            appKey: app.key,
-                        });
-                    }
-                }
-                const manifestKey = getManifestKey(app);
-                // Generate type definitions
-                const generator = new AstTypeGenerator();
-                const typeDefinitionString = await generator.generateTypes({
-                    app,
-                    authenticationId,
-                    sdk,
-                });
-                result.typeDefinitions[manifestKey] = typeDefinitionString;
-                onProgress?.({
-                    type: "type_generated",
-                    manifestKey,
-                    sizeBytes: typeDefinitionString.length,
-                });
-                // Write to file if skipWrite is false
-                if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
-                    const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
-                    await writeFile(filePath, typeDefinitionString, "utf8");
-                    result.writtenFiles[manifestKey] = filePath;
-                    onProgress?.({
-                        type: "file_written",
-                        manifestKey,
-                        filePath,
-                    });
-                }
-                onProgress?.({
-                    type: "app_processing_complete",
-                    appKey: app.key,
-                });
-            }
-            catch (error) {
-                const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
-                onProgress?.({
-                    type: "app_processing_error",
-                    appKey: app.key,
-                    error: errorMessage,
-                });
-                if (error instanceof ZapierValidationError) {
-                    throw error; // Preserve the specific error type
-                }
-                else {
-                    throw new ZapierUnknownError(errorMessage, {
-                        cause: error, // Works for both Error and non-Error
-                    });
-                }
-            }
-        }
-        return result;
-    }, GenerateAppTypesSchema);
-    return {
-        generateAppTypes,
-        context: {
-            meta: {
-                generateAppTypes: {
-                    categories: ["utility"],
-                    inputSchema: GenerateAppTypesSchema,
-                },
-            },
-        },
-    };
-};

package/dist/src/plugins/generateAppTypes/schemas.d.ts

@@ -1,58 +0,0 @@
-import { z } from "zod";
-import type { AppItem } from "@zapier/zapier-sdk";
-export declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString>;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    skipWrite: z.ZodOptional<z.ZodBoolean>;
-    typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
-    onProgress?: (event: AppTypesProgressEvent) => void;
-};
-export type AppTypesProgressEvent = {
-    type: "apps_lookup_start";
-    count: number;
-} | {
-    type: "app_found";
-    app: AppItem;
-} | {
-    type: "apps_lookup_complete";
-    count: number;
-} | {
-    type: "authentications_lookup_start";
-    count: number;
-} | {
-    type: "authentications_lookup_complete";
-    count: number;
-} | {
-    type: "app_processing_start";
-    appKey: string;
-    slug?: string;
-} | {
-    type: "authentication_matched";
-    appKey: string;
-    authenticationId: string;
-    authenticationTitle: string;
-} | {
-    type: "authentication_not_matched";
-    appKey: string;
-} | {
-    type: "type_generated";
-    manifestKey: string;
-    sizeBytes: number;
-} | {
-    type: "file_written";
-    manifestKey: string;
-    filePath: string;
-} | {
-    type: "app_processing_complete";
-    appKey: string;
-} | {
-    type: "app_processing_error";
-    appKey: string;
-    error: string;
-};
-export interface GenerateAppTypesResult {
-    typeDefinitions: Record<string, string>;
-    writtenFiles?: Record<string, string>;
-}

package/dist/src/plugins/generateAppTypes/schemas.js

@@ -1,21 +0,0 @@
-import { z } from "zod";
-export const GenerateAppTypesSchema = z
-    .object({
-    appKeys: z
-        .array(z.string().min(1, "App key cannot be empty"))
-        .min(1, "At least one app key is required")
-        .describe("One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')"),
-    authenticationIds: z
-        .array(z.string())
-        .optional()
-        .describe("Authentication IDs to use for type generation (e.g., ['123', '456'])"),
-    skipWrite: z
-        .boolean()
-        .optional()
-        .describe("If true, returns type definitions without writing to disk. If false or omitted, writes type files."),
-    typesOutputDirectory: z
-        .string()
-        .optional()
-        .describe("Directory for TypeScript type files. Required when skipWrite is false or omitted."),
-})
-    .describe("Generate TypeScript type definitions for apps - can optionally write to disk or just return type strings");

package/dist/src/plugins/getLoginConfigPath/index.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { GetLoginConfigPathSchema, type GetLoginConfigPathOptions } from "./schemas";
-export interface GetLoginConfigPathPluginProvides {
-    getLoginConfigPath: (options?: GetLoginConfigPathOptions) => Promise<string>;
-    context: {
-        meta: {
-            getLoginConfigPath: {
-                inputSchema: typeof GetLoginConfigPathSchema;
-            };
-        };
-    };
-}
-export declare const getLoginConfigPathPlugin: Plugin<{}, // requires no existing SDK methods
-{}, // requires no context
-GetLoginConfigPathPluginProvides>;

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

@@ -1,19 +0,0 @@
-import { GetLoginConfigPathSchema, } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
-export const getLoginConfigPathPlugin = () => {
-    const getLoginConfigPathWithSdk = createFunction(async function getLoginConfigPathWithSdk(_options) {
-        return getConfigPath();
-    }, GetLoginConfigPathSchema);
-    return {
-        getLoginConfigPath: getLoginConfigPathWithSdk,
-        context: {
-            meta: {
-                getLoginConfigPath: {
-                    categories: ["utility"],
-                    inputSchema: GetLoginConfigPathSchema,
-                },
-            },
-        },
-    };
-};

package/dist/src/plugins/getLoginConfigPath/schemas.d.ts

@@ -1,3 +0,0 @@
-import { z } from "zod";
-export declare const GetLoginConfigPathSchema: z.ZodObject<{}, z.core.$strip>;
-export type GetLoginConfigPathOptions = z.infer<typeof GetLoginConfigPathSchema>;

package/dist/src/plugins/getLoginConfigPath/schemas.js

@@ -1,5 +0,0 @@
-import { z } from "zod";
-// Get login config path schema - simple command with no parameters
-export const GetLoginConfigPathSchema = z
-    .object({})
-    .describe("Show the path to the login configuration file");

package/dist/src/plugins/index.d.ts

@@ -1,8 +0,0 @@
-export { loginPlugin } from "./login";
-export { logoutPlugin } from "./logout";
-export { mcpPlugin } from "./mcp";
-export { bundleCodePlugin } from "./bundleCode";
-export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
-export { addPlugin } from "./add";
-export { generateAppTypesPlugin } from "./generateAppTypes";
-export { buildManifestPlugin } from "./buildManifest";

package/dist/src/plugins/index.js

@@ -1,8 +0,0 @@
-export { loginPlugin } from "./login";
-export { logoutPlugin } from "./logout";
-export { mcpPlugin } from "./mcp";
-export { bundleCodePlugin } from "./bundleCode";
-export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
-export { addPlugin } from "./add";
-export { generateAppTypesPlugin } from "./generateAppTypes";
-export { buildManifestPlugin } from "./buildManifest";

package/dist/src/plugins/login/index.d.ts

@@ -1,23 +0,0 @@
-import type { Plugin, ResolvedCredentials } from "@zapier/zapier-sdk";
-import type { EventEmissionContext } from "@zapier/zapier-sdk";
-import { LoginSchema, type LoginOptions } from "./schemas";
-interface CliContext {
-    session_id?: string | null;
-    selected_api?: string | null;
-    app_id?: number | null;
-    app_version_id?: number | null;
-    resolveCredentials: () => Promise<ResolvedCredentials | undefined>;
-}
-interface LoginPluginProvides {
-    login: (options: LoginOptions) => Promise<void>;
-    context: {
-        meta: {
-            login: {
-                inputSchema: typeof LoginSchema;
-                categories: string[];
-            };
-        };
-    };
-}
-export declare const loginPlugin: Plugin<{}, EventEmissionContext & CliContext, LoginPluginProvides>;
-export type { LoginPluginProvides };

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

@@ -1,95 +0,0 @@
-import { isCredentialsObject } from "@zapier/zapier-sdk";
-import login from "../../utils/auth/login";
-import { getLoggedInUser, } from "@zapier/zapier-sdk-cli-login";
-import { LoginSchema } from "./schemas";
-import { buildCliCommandExecutedEvent } from "../../telemetry/builders";
-import cliPackageJson from "../../../package.json";
-const CLI_COMMAND_EXECUTED_EVENT_SUBJECT = "platform.sdk.CliCommandExecutedEvent";
-function toPkceCredentials(credentials) {
-    if (credentials &&
-        isCredentialsObject(credentials) &&
-        !("clientSecret" in credentials)) {
-        return {
-            type: "pkce",
-            clientId: credentials.clientId,
-            baseUrl: credentials.baseUrl,
-            scope: credentials.scope,
-        };
-    }
-    return undefined;
-}
-export const loginPlugin = ({ context }) => {
-    // Wrap the login function to emit telemetry events
-    const loginWithTelemetry = async (options) => {
-        const startTime = Date.now();
-        let success = false;
-        let errorMessage = null;
-        let accountId = null;
-        let customUserId = null;
-        try {
-            const timeoutSeconds = options.timeout
-                ? parseInt(options.timeout, 10)
-                : 300;
-            if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
-                throw new Error("Timeout must be a positive number");
-            }
-            // Resolve credentials from options and env vars
-            const resolvedCredentials = await context.resolveCredentials();
-            const pkceCredentials = toPkceCredentials(resolvedCredentials);
-            await login({
-                timeoutMs: timeoutSeconds * 1000,
-                credentials: pkceCredentials,
-            });
-            // Get user info after successful login
-            const user = await getLoggedInUser();
-            accountId = user.accountId;
-            customUserId = user.customUserId;
-            console.log(`✅ Successfully logged in as ${user.email}`);
-            success = true;
-        }
-        catch (error) {
-            success = false;
-            errorMessage = error instanceof Error ? error.message : "Login failed";
-            throw error;
-        }
-        finally {
-            // Emit CLI command executed event if event emission is available
-            const event = buildCliCommandExecutedEvent({
-                data: {
-                    cli_primary_command: "login",
-                    success_flag: success,
-                    execution_duration_ms: Date.now() - startTime,
-                    exit_code: success ? 0 : 1,
-                    error_message: errorMessage,
-                    command_category: "authentication",
-                    requires_auth: false,
-                    cli_arguments: [
-                        "login",
-                        options.timeout ? `--timeout=${options.timeout}` : null,
-                    ].filter(Boolean),
-                },
-                context: {
-                    session_id: context.session_id,
-                    selected_api: context.selected_api,
-                    app_id: context.app_id,
-                    app_version_id: context.app_version_id,
-                    customuser_id: customUserId,
-                    account_id: accountId,
-                },
-                cliVersion: cliPackageJson.version,
-            });
-            context.eventEmission.emit(CLI_COMMAND_EXECUTED_EVENT_SUBJECT, event);
-        }
-    };
-    return {
-        login: loginWithTelemetry,
-        context: {
-            meta: {
-                login: {
-                    categories: ["account"],
-                    inputSchema: LoginSchema,
-                },
-            },
-        },
-    };
-};

package/dist/src/plugins/login/schemas.d.ts

@@ -1,5 +0,0 @@
-import { z } from "zod";
-export declare const LoginSchema: z.ZodObject<{
-    timeout: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type LoginOptions = z.infer<typeof LoginSchema>;

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

@@ -1,10 +0,0 @@
-import { z } from "zod";
-// Login schema
-export const LoginSchema = z
-    .object({
-    timeout: z
-        .string()
-        .optional()
-        .describe("Login timeout in seconds (default: 300)"),
-})
-    .describe("Log in to Zapier to access your account");

package/dist/src/plugins/logout/index.d.ts

@@ -1,15 +0,0 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { LogoutSchema, type LogoutOptions } from "./schemas";
-interface LogoutPluginProvides {
-    logout: (options: LogoutOptions) => Promise<void>;
-    context: {
-        meta: {
-            logout: {
-                inputSchema: typeof LogoutSchema;
-                categories: string[];
-            };
-        };
-    };
-}
-export declare const logoutPlugin: Plugin<{}, {}, LogoutPluginProvides>;
-export type { LogoutPluginProvides };