@zapier/zapier-sdk 0.65.0 → 0.68.0

package/dist/plugins/fetch/index.js

@@ -1,4 +1,4 @@
-import { definePlugin } from "../../utils/plugin-utils";
+import { definePlugin } from "kitcore";
 import { ZapierRelayError, ZapierTimeoutError } from "../../types/errors";
 import { FetchUrlSchema, FetchInitSchema, FetchInitZapierFieldsSchema, } from "./schemas";
 import { z } from "zod";
@@ -6,11 +6,11 @@ import { resolveConnectionId } from "../../utils/domain-utils";
 import { combineAbortSignals, createTimeoutAbortSignal, } from "../../utils/abort-utils";
 import { isPlainObject } from "../../utils/type-guard-utils";
 import { buildHttpRequestContext } from "@zapier/policy-context";
-// fetch() doesn't use createFunction/createPaginatedFunction (its signature
-// doesn't fit the single-options-object pattern), so we wire up telemetry
-// context tracking manually.
-import { isTelemetryNested, runWithTelemetryContext, } from "../../utils/telemetry-context";
-import { createValidator } from "../../utils/validation";
+// fetch() doesn't go through createPluginMethod (its signature is variadic,
+// not single-options), so it enters its own method scope and fires
+// onMethodStart / onMethodEnd hooks directly.
+import { getCurrentDepth, runInMethodScope } from "kitcore";
+import { createValidator } from "kitcore";
 /**
  * Transforms full URLs into Relay format: /relay/{domain}/{path}
  */
@@ -92,18 +92,31 @@ function buildAbortHandle({ maxTimeSeconds, callerSignal, }) {
 const FetchInitSdkValidationSchema = z
     .looseObject(FetchInitZapierFieldsSchema.shape)
     .optional();
-const validateFetchInit = createValidator(FetchInitSdkValidationSchema);
 /**
  * Fetch plugin, the primary way to make authenticated HTTP requests through Zapier's Relay service.
  * Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.
  */
 export const fetchPlugin = definePlugin((sdk) => {
+    // Bind the validator to the head's `adaptError` so validation
+    // failures surface as `ZapierValidationError` rather than the
+    // neutral `CoreError` kitcore would otherwise fall back to.
+    const validateFetchInit = createValidator(FetchInitSdkValidationSchema, {
+        adaptError: sdk.context.core?.adaptError,
+    });
     return {
         fetch: async function fetch(url, init) {
-            return runWithTelemetryContext(async () => {
+            return runInMethodScope(async () => {
                 const { api } = sdk.context;
+                const { onMethodStart, onMethodEnd } = sdk.context.hooks;
                 const startTime = Date.now();
-                const isNested = isTelemetryNested();
+                const depth = getCurrentDepth();
+                const args = init === undefined ? [url] : [url, init];
+                onMethodStart?.({
+                    methodName: "fetch",
+                    args,
+                    isPaginated: false,
+                    depth,
+                });
                 try {
                     if (init) {
                         validateFetchInit(init);
@@ -167,17 +180,13 @@ export const fetchPlugin = definePlugin((sdk) => {
                                 statusCode: result.status,
                             });
                         }
-                        if (!isNested) {
-                            sdk.context.eventEmission.emitMethodCalled({
-                                method_name: "fetch",
-                                execution_duration_ms: Date.now() - startTime,
-                                success_flag: true,
-                                error_message: null,
-                                error_type: null,
-                                argument_count: init ? 2 : 1,
-                                is_paginated: false,
-                            });
-                        }
+                        onMethodEnd?.({
+                            methodName: "fetch",
+                            args,
+                            isPaginated: false,
+                            depth,
+                            durationMs: Date.now() - startTime,
+                        });
                         return result;
                     }
                     catch (error) {
@@ -192,17 +201,14 @@ export const fetchPlugin = definePlugin((sdk) => {
                     }
                 }
                 catch (error) {
-                    if (!isNested) {
-                        sdk.context.eventEmission.emitMethodCalled({
-                            method_name: "fetch",
-                            execution_duration_ms: Date.now() - startTime,
-                            success_flag: false,
-                            error_message: error instanceof Error ? error.message : String(error),
-                            error_type: error instanceof Error ? error.constructor.name : "Unknown",
-                            argument_count: init ? 2 : 1,
-                            is_paginated: false,
-                        });
-                    }
+                    onMethodEnd?.({
+                        methodName: "fetch",
+                        args,
+                        isPaginated: false,
+                        depth,
+                        durationMs: Date.now() - startTime,
+                        error: error instanceof Error ? error : new Error(String(error)),
+                    });
                     throw error;
                 }
             });
@@ -215,7 +221,11 @@ export const fetchPlugin = definePlugin((sdk) => {
                         "(OAuth tokens, API keys, etc.) into the outgoing request. " +
                         "Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.",
                     packages: ["sdk", "cli", "mcp"],
-                    categories: ["http"],
+                    // Auto-derive would produce "Http"/"Https" from the key alone;
+                    // declare the title explicitly here so the registry renders
+                    // "HTTP Request". Other plugins in this category use the bare
+                    // string "http"; the object form wins regardless of order.
+                    categories: [{ key: "http", title: "HTTP Request" }],
                     returnType: "Response",
                     inputParameters: [
                         { name: "url", schema: FetchUrlSchema },

package/dist/plugins/fetch/schemas.d.ts

@@ -11,8 +11,8 @@ export declare const FetchInitSchema: z.ZodOptional<z.ZodObject<{
     method: z.ZodOptional<z.ZodEnum<{
         POST: "POST";
         GET: "GET";
-        PUT: "PUT";
         DELETE: "DELETE";
+        PUT: "PUT";
         PATCH: "PATCH";
         HEAD: "HEAD";
         OPTIONS: "OPTIONS";

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

@@ -20,7 +20,7 @@ export declare const findFirstConnectionPlugin: (sdk: {
         cursor?: string;
         pageSize?: number;
         maxItems?: number;
-    }) | undefined) => import("../..").PaginatedSdkResult<{
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
         date: string;
         is_invite_only: boolean;
         is_private: boolean;
@@ -52,14 +52,14 @@ export declare const findFirstConnectionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listConnections: import("../..").PluginMeta;
+            listConnections: import("kitcore").PluginMeta<unknown>;
         };
     };
 } & {
     context: import("../eventEmission").EventEmissionContext;
 } & {
     context: {
-        meta: Record<string, import("../..").PluginMeta>;
+        meta: Record<string, import("kitcore").PluginMeta>;
     };
 }) => {
     findFirstConnection: (options?: {
@@ -107,7 +107,7 @@ export declare const findFirstConnectionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            findFirstConnection: import("../..").PluginMeta;
+            findFirstConnection: import("kitcore").PluginMeta<unknown>;
         };
     };
 };

package/dist/plugins/findFirstConnection/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findFirstConnection/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrC,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,UAAU,CACxD,OAAO,yBAAyB,CACjC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findFirstConnection/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BrC,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG,UAAU,CACxD,OAAO,yBAAyB,CACjC,CAAC"}

package/dist/plugins/findFirstConnection/index.js

@@ -1,7 +1,8 @@
-import { definePlugin } from "../../utils/plugin-utils";
-import { createPluginMethod } from "../../utils/plugin-utils";
+import { definePlugin } from "kitcore";
+import { createPluginMethod } from "kitcore";
 import { FindFirstConnectionSchema } from "./schemas";
 import { ConnectionItemSchema } from "../../schemas/Connection";
+import { connectionItemFormatter } from "../../formatters/connection";
 import { ZapierResourceNotFoundError } from "../../types/errors";
 export const findFirstConnectionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
     name: "findFirstConnection",
@@ -10,6 +11,7 @@ export const findFirstConnectionPlugin = definePlugin((sdk) => createPluginMetho
     itemType: "Connection",
     inputSchema: FindFirstConnectionSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     handler: async ({ sdk, options = {} }) => {
         const connectionsResponse = await sdk.listConnections({
             ...options,

package/dist/plugins/findFirstConnection/schemas.d.ts

@@ -4,10 +4,10 @@ export declare const FindFirstConnectionSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     search: z.ZodOptional<z.ZodString>;
     appKey: z.ZodOptional<z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     }>;
     app: z.ZodOptional<z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     }>;
     owner: z.ZodOptional<z.ZodString>;
     account: z.ZodOptional<z.ZodString>;

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

@@ -20,7 +20,7 @@ export declare const findUniqueConnectionPlugin: (sdk: {
         cursor?: string;
         pageSize?: number;
         maxItems?: number;
-    }) | undefined) => import("../..").PaginatedSdkResult<{
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
         date: string;
         is_invite_only: boolean;
         is_private: boolean;
@@ -52,14 +52,14 @@ export declare const findUniqueConnectionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listConnections: import("../..").PluginMeta;
+            listConnections: import("kitcore").PluginMeta<unknown>;
         };
     };
 } & {
     context: import("../eventEmission").EventEmissionContext;
 } & {
     context: {
-        meta: Record<string, import("../..").PluginMeta>;
+        meta: Record<string, import("kitcore").PluginMeta>;
     };
 }) => {
     findUniqueConnection: (options?: {
@@ -107,7 +107,7 @@ export declare const findUniqueConnectionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            findUniqueConnection: import("../..").PluginMeta;
+            findUniqueConnection: import("kitcore").PluginMeta<unknown>;
         };
     };
 };

package/dist/plugins/findUniqueConnection/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueConnection/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BtC,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,OAAO,0BAA0B,CAClC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueConnection/index.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCtC,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,OAAO,0BAA0B,CAClC,CAAC"}

package/dist/plugins/findUniqueConnection/index.js

@@ -1,8 +1,9 @@
-import { definePlugin } from "../../utils/plugin-utils";
-import { createPluginMethod } from "../../utils/plugin-utils";
+import { definePlugin } from "kitcore";
+import { createPluginMethod } from "kitcore";
 import { FindUniqueConnectionSchema } from "./schemas";
 import { ZapierResourceNotFoundError, ZapierValidationError, } from "../../types/errors";
 import { ConnectionItemSchema } from "../../schemas/Connection";
+import { connectionItemFormatter } from "../../formatters/connection";
 export const findUniqueConnectionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
     name: "findUniqueConnection",
     categories: ["connection"],
@@ -10,6 +11,7 @@ export const findUniqueConnectionPlugin = definePlugin((sdk) => createPluginMeth
     itemType: "Connection",
     inputSchema: FindUniqueConnectionSchema,
     outputSchema: ConnectionItemSchema,
+    formatter: connectionItemFormatter,
     handler: async ({ sdk, options = {} }) => {
         const connectionsResponse = await sdk.listConnections({
             ...options,

package/dist/plugins/findUniqueConnection/schemas.d.ts

@@ -4,10 +4,10 @@ export declare const FindUniqueConnectionSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     search: z.ZodOptional<z.ZodString>;
     appKey: z.ZodOptional<z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     }>;
     app: z.ZodOptional<z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     }>;
     owner: z.ZodOptional<z.ZodString>;
     account: z.ZodOptional<z.ZodString>;

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

@@ -16,7 +16,7 @@ export declare const getActionPlugin: (sdk: {
         cursor?: string;
         pageSize?: number;
         maxItems?: number;
-    }) | undefined) => import("../..").PaginatedSdkResult<{
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
         description: string;
         key: string;
         app_key: string;
@@ -31,7 +31,144 @@ export declare const getActionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listActions: import("../..").PluginMeta;
+            listActions: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    getApp: (options?: {
+        app: string;
+    } | {
+        appKey: string;
+    } | undefined) => Promise<{
+        data: {
+            slug: string;
+            title: string;
+            key: string;
+            implementation_id: string;
+            description?: string | undefined;
+            is_hidden?: boolean | undefined;
+            auth_type?: string | undefined;
+            actions?: {
+                read?: number | undefined;
+                read_bulk?: number | undefined;
+                write?: number | undefined;
+                search?: number | undefined;
+                search_or_write?: number | undefined;
+                search_and_write?: number | undefined;
+                filter?: number | undefined;
+            } | undefined;
+            is_deprecated?: boolean | undefined;
+            is_beta?: boolean | undefined;
+            is_premium?: boolean | undefined;
+            age_in_days?: number | undefined;
+            banner?: string | undefined;
+            categories?: {
+                id: number;
+                name: string;
+                slug: string;
+            }[] | undefined;
+            images?: {
+                url_16x16?: string | undefined;
+                url_32x32?: string | undefined;
+                url_64x64?: string | undefined;
+                url_128x128?: string | undefined;
+            } | undefined;
+            popularity?: number | undefined;
+            has_filters?: boolean | undefined;
+            has_reads?: boolean | undefined;
+            has_searches?: boolean | undefined;
+            has_searches_or_writes?: boolean | undefined;
+            has_upfront_fields?: boolean | undefined;
+            has_writes?: boolean | undefined;
+            is_built_in?: boolean | undefined;
+            is_featured?: boolean | undefined;
+            is_invite?: boolean | undefined;
+            is_public?: boolean | undefined;
+            is_upcoming?: boolean | undefined;
+            visibility?: string | undefined;
+            primary_color?: string | undefined;
+            secondary_color?: string | undefined;
+            classification?: string | undefined;
+            api_docs_url?: string | undefined;
+            image?: string | undefined;
+            version?: string | undefined;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            getApp: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    listApps: (options?: ({
+        search?: string | undefined;
+        apps?: string[] | undefined;
+        appKeys?: string[] | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
+        slug: string;
+        title: string;
+        key: string;
+        implementation_id: string;
+        description?: string | undefined;
+        is_hidden?: boolean | undefined;
+        auth_type?: string | undefined;
+        actions?: {
+            read?: number | undefined;
+            read_bulk?: number | undefined;
+            write?: number | undefined;
+            search?: number | undefined;
+            search_or_write?: number | undefined;
+            search_and_write?: number | undefined;
+            filter?: number | undefined;
+        } | undefined;
+        is_deprecated?: boolean | undefined;
+        is_beta?: boolean | undefined;
+        is_premium?: boolean | undefined;
+        age_in_days?: number | undefined;
+        banner?: string | undefined;
+        categories?: {
+            id: number;
+            name: string;
+            slug: string;
+        }[] | undefined;
+        images?: {
+            url_16x16?: string | undefined;
+            url_32x32?: string | undefined;
+            url_64x64?: string | undefined;
+            url_128x128?: string | undefined;
+        } | undefined;
+        popularity?: number | undefined;
+        has_filters?: boolean | undefined;
+        has_reads?: boolean | undefined;
+        has_searches?: boolean | undefined;
+        has_searches_or_writes?: boolean | undefined;
+        has_upfront_fields?: boolean | undefined;
+        has_writes?: boolean | undefined;
+        is_built_in?: boolean | undefined;
+        is_featured?: boolean | undefined;
+        is_invite?: boolean | undefined;
+        is_public?: boolean | undefined;
+        is_upcoming?: boolean | undefined;
+        visibility?: string | undefined;
+        primary_color?: string | undefined;
+        secondary_color?: string | undefined;
+        classification?: string | undefined;
+        api_docs_url?: string | undefined;
+        image?: string | undefined;
+        version?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listApps: import("kitcore").PluginMeta<unknown>;
         };
     };
 } & {
@@ -42,7 +179,7 @@ export declare const getActionPlugin: (sdk: {
     context: import("../eventEmission").EventEmissionContext;
 } & {
     context: {
-        meta: Record<string, import("../..").PluginMeta>;
+        meta: Record<string, import("kitcore").PluginMeta>;
     };
 }) => {
     getAction: (options?: {
@@ -70,7 +207,7 @@ export declare const getActionPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            getAction: import("../..").PluginMeta;
+            getAction: import("kitcore").PluginMeta<unknown>;
         };
     };
 };

package/dist/plugins/getAction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getAction/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAiB3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAHjB;QAAE,GAAG,EAAE,SAAS,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6C5B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getAction/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAsB3C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAHf;QAAE,GAAG,EAAE,SAAS,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8C9B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/plugins/getAction/index.js

@@ -1,10 +1,11 @@
-import { definePlugin } from "../../utils/plugin-utils";
-import { createPluginMethod } from "../../utils/plugin-utils";
+import { definePlugin } from "kitcore";
+import { createPluginMethod } from "kitcore";
 import { GetActionInputSchema } from "./schemas";
 import { ZapierResourceNotFoundError } from "../../types/errors";
 import { appKeyResolver, actionTypeResolver, actionKeyResolver, } from "../../resolvers";
 import { ActionItemSchema } from "../../schemas/Action";
-import { setMethodMetadata } from "../../utils/telemetry-context";
+import { actionItemFormatter } from "../../formatters/action";
+import { setMethodMetadata } from "../eventEmission/method-metadata";
 export const getActionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
     name: "getAction",
     categories: ["action"],
@@ -12,6 +13,7 @@ export const getActionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
     itemType: "Action",
     inputSchema: GetActionInputSchema,
     outputSchema: ActionItemSchema,
+    formatter: actionItemFormatter,
     resolvers: {
         app: appKeyResolver,
         actionType: actionTypeResolver,

package/dist/plugins/getAction/schemas.d.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import type { ActionItem } from "../../types/domain";
 export declare const GetActionSchema: z.ZodObject<{
     app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
         filter: "filter";
@@ -15,12 +15,12 @@ export declare const GetActionSchema: z.ZodObject<{
         search_or_write: "search_or_write";
     }>;
     action: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     };
 }, z.core.$strip>;
 declare const GetActionSchemaDeprecated: z.ZodObject<{
     appKey: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
         filter: "filter";
@@ -36,7 +36,7 @@ declare const GetActionSchemaDeprecated: z.ZodObject<{
 }, z.core.$strip>;
 export declare const GetActionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
     app: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
         filter: "filter";
@@ -49,11 +49,11 @@ export declare const GetActionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
         search_or_write: "search_or_write";
     }>;
     action: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     };
 }, z.core.$strip>, z.ZodObject<{
     appKey: z.ZodString & {
-        _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
         filter: "filter";