@zapier/zapier-sdk 0.2.0 → 0.3.0

package/dist/api/client.js

@@ -10,6 +10,7 @@ exports.createZapierApi = createZapierApi;
 const auth_1 = require("./auth");
 const debug_1 = require("./debug");
 const polling_1 = require("./polling");
+const auth_2 = require("../auth");
 function createZapierApi(options) {
     const { baseUrl, token, getToken, debug = false, fetch: originalFetch = globalThis.fetch, } = options;
     const debugLog = (0, debug_1.createDebugLogger)(debug);
@@ -37,7 +38,7 @@ function createZapierApi(options) {
                 resolvedToken = await getToken();
             }
             if (!resolvedToken) {
-                resolvedToken = process.env.ZAPIER_TOKEN;
+                resolvedToken = (0, auth_2.getTokenFromEnv)();
             }
             if (resolvedToken) {
                 headers.Authorization = (0, auth_1.getAuthorizationHeader)(resolvedToken);
@@ -110,7 +111,7 @@ function createZapierApi(options) {
         },
         requireAuthTo(operation) {
             // Check if any authentication method is available
-            if (!token && !getToken && !process.env.ZAPIER_TOKEN) {
+            if (!token && !getToken && !(0, auth_2.getTokenFromEnv)()) {
                 throw new Error(`Authentication token is required to ${operation}. Please provide token in options or set ZAPIER_TOKEN environment variable.`);
             }
         },

package/dist/api/types.d.ts

@@ -52,7 +52,7 @@ export interface Action {
     name: string;
     description: string;
     appKey: string;
-    type: "create" | "update" | "search" | "delete" | "read";
+    type: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
     inputFields: Field[];
     outputFields: Field[];
 }

package/dist/auth.d.ts

@@ -0,0 +1,59 @@
+/**
+ * SDK Authentication Utilities
+ *
+ * This module provides SDK-level authentication utilities, including
+ * token acquisition, refresh, and user information extraction.
+ */
+import type { EventCallback } from "./types/events";
+export type { SdkEvent, AuthEvent, ApiEvent, LoadingEvent, EventCallback, } from "./types/events";
+export interface AuthOptions {
+    onEvent?: EventCallback;
+    fetch?: typeof globalThis.fetch;
+}
+export interface LoginData {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+}
+export declare function updateLogin(loginData: LoginData): void;
+/**
+ * Attempts to read a valid JWT token from the CLI configuration.
+ * Automatically refreshes expired tokens when possible.
+ * Returns undefined if no valid token is found or refresh fails.
+ */
+export declare function getTokenFromConfig(options?: AuthOptions): Promise<string | undefined>;
+/**
+ * Gets the ZAPIER_TOKEN from environment variables.
+ * Returns undefined if not set.
+ */
+export declare function getTokenFromEnv(): string | undefined;
+/**
+ * Attempts to get a token with the following precedence:
+ * 1. ZAPIER_TOKEN environment variable
+ * 2. Valid JWT from CLI configuration (with auto-refresh)
+ *
+ * Returns undefined if no valid token is found.
+ */
+export declare function getTokenFromEnvOrConfig(options?: AuthOptions): Promise<string | undefined>;
+/**
+ * Gets the current JWT token, refreshing if necessary.
+ * Returns undefined if no valid token is available.
+ */
+export declare function getValidJwt(options?: AuthOptions): Promise<string | undefined>;
+/**
+ * Gets the logged-in user information from JWT token.
+ * Automatically refreshes token if expired.
+ */
+export declare function getLoggedInUser(options?: AuthOptions): Promise<{
+    accountId: number;
+    customUserId: number;
+    email: string;
+}>;
+/**
+ * Clears stored login information.
+ */
+export declare function logout(options?: Pick<AuthOptions, "onEvent">): void;
+/**
+ * Gets the path to the configuration file.
+ */
+export declare function getConfigPath(): string;

package/dist/auth.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * SDK Authentication Utilities
+ *
+ * This module provides SDK-level authentication utilities, including
+ * token acquisition, refresh, and user information extraction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateLogin = updateLogin;
+exports.getTokenFromConfig = getTokenFromConfig;
+exports.getTokenFromEnv = getTokenFromEnv;
+exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
+exports.getValidJwt = getValidJwt;
+exports.getLoggedInUser = getLoggedInUser;
+exports.logout = logout;
+exports.getConfigPath = getConfigPath;
+// Import type { RequestOptions } from "./api/types"; // Commented out - not used yet
+let config;
+// Constants needed for token refresh
+const ZAPIER_BASE = "https://zapier.com";
+const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+const AUTH_MODE_HEADER = "X-Auth";
+// Utility functions for config management
+function getConfig() {
+    if (!config) {
+        const ConfModule = require("conf");
+        const Conf = ConfModule.default || ConfModule;
+        config = new Conf({ projectName: "zapier-sdk-cli" });
+    }
+    return config;
+}
+function updateLogin(loginData) {
+    const cfg = getConfig();
+    cfg.set("login_jwt", loginData.access_token);
+    cfg.set("login_refresh_token", loginData.refresh_token);
+    cfg.set("login_expires_at", Date.now() + loginData.expires_in * 1000);
+}
+function clearLogin() {
+    const cfg = getConfig();
+    cfg.delete("login_jwt");
+    cfg.delete("login_refresh_token");
+    cfg.delete("login_expires_at");
+}
+// JWT utility functions
+function decodeJwtOrThrow(jwt) {
+    if (typeof jwt !== "string") {
+        throw new Error("Expected JWT to be a string");
+    }
+    let jsonwebtoken;
+    try {
+        jsonwebtoken = require("jsonwebtoken");
+    }
+    catch {
+        throw new Error("jsonwebtoken not available - this function requires CLI dependencies");
+    }
+    const decodedJwt = jsonwebtoken.decode(jwt, { complete: true });
+    if (!decodedJwt) {
+        throw new Error("Could not decode JWT");
+    }
+    if (typeof decodedJwt.payload === "string") {
+        throw new Error("Did not expect JWT payload to be a string");
+    }
+    return decodedJwt;
+}
+/**
+ * Refreshes an expired JWT token using the refresh token.
+ * Returns the new access token or throws an error.
+ */
+async function refreshJwt(refreshToken, options = {}) {
+    const { onEvent, fetch = globalThis.fetch } = options;
+    try {
+        onEvent?.({
+            type: "auth_refreshing",
+            payload: {
+                message: "Refreshing your token...",
+                operation: "token_refresh",
+            },
+            timestamp: Date.now(),
+        });
+        const response = await fetch(`${ZAPIER_BASE}/oauth/token/`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                [AUTH_MODE_HEADER]: "no",
+            },
+            body: new URLSearchParams({
+                client_id: LOGIN_CLIENT_ID,
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Token refresh failed: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Update stored login data
+        updateLogin(data);
+        onEvent?.({
+            type: "auth_success",
+            payload: {
+                message: "Token refreshed successfully",
+                operation: "token_refresh",
+            },
+            timestamp: Date.now(),
+        });
+        return data.access_token;
+    }
+    catch (error) {
+        // If refresh fails, clear stored login
+        clearLogin();
+        const errorMessage = `Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`;
+        onEvent?.({
+            type: "auth_error",
+            payload: {
+                message: errorMessage,
+                error: errorMessage,
+                operation: "token_refresh",
+            },
+            timestamp: Date.now(),
+        });
+        throw error;
+    }
+}
+/**
+ * Attempts to read a valid JWT token from the CLI configuration.
+ * Automatically refreshes expired tokens when possible.
+ * Returns undefined if no valid token is found or refresh fails.
+ */
+async function getTokenFromConfig(options = {}) {
+    try {
+        const cfg = getConfig();
+        const jwt = cfg.get("login_jwt");
+        const refreshToken = cfg.get("login_refresh_token");
+        const expiresAt = cfg.get("login_expires_at");
+        // Check if we have all required fields
+        if (!jwt || !refreshToken || !expiresAt) {
+            return undefined;
+        }
+        // Check if token is still valid (with 30 second buffer)
+        if (expiresAt > Date.now() + 30 * 1000) {
+            return jwt;
+        }
+        // Token is expired - attempt to refresh
+        try {
+            return await refreshJwt(refreshToken, options);
+        }
+        catch {
+            // If refresh fails, return undefined
+            return undefined;
+        }
+    }
+    catch {
+        // If conf is not available or any other error occurs, return undefined
+        return undefined;
+    }
+}
+/**
+ * Gets the ZAPIER_TOKEN from environment variables.
+ * Returns undefined if not set.
+ */
+function getTokenFromEnv() {
+    return process.env.ZAPIER_TOKEN;
+}
+/**
+ * Attempts to get a token with the following precedence:
+ * 1. ZAPIER_TOKEN environment variable
+ * 2. Valid JWT from CLI configuration (with auto-refresh)
+ *
+ * Returns undefined if no valid token is found.
+ */
+async function getTokenFromEnvOrConfig(options = {}) {
+    // First priority: environment variable
+    const envToken = getTokenFromEnv();
+    if (envToken) {
+        return envToken;
+    }
+    // Second priority: CLI configuration (with auto-refresh)
+    return getTokenFromConfig(options);
+}
+/**
+ * Gets the current JWT token, refreshing if necessary.
+ * Returns undefined if no valid token is available.
+ */
+async function getValidJwt(options = {}) {
+    try {
+        const cfg = getConfig();
+        const jwt = cfg.get("login_jwt");
+        const refreshToken = cfg.get("login_refresh_token");
+        const expiresAt = cfg.get("login_expires_at");
+        // Check if we have all required fields
+        if (!jwt || !refreshToken || !expiresAt) {
+            return undefined;
+        }
+        // Check if token is still valid (with 30 second buffer)
+        if (expiresAt > Date.now() + 30 * 1000) {
+            return jwt;
+        }
+        // Token is expired - attempt to refresh
+        return await refreshJwt(refreshToken, options);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Gets the logged-in user information from JWT token.
+ * Automatically refreshes token if expired.
+ */
+async function getLoggedInUser(options = {}) {
+    const jwt = await getValidJwt(options);
+    if (!jwt) {
+        throw new Error("No valid authentication token available. Please login first.");
+    }
+    let decodedJwt = decodeJwtOrThrow(jwt);
+    if (decodedJwt.payload["sub_type"] == "service") {
+        decodedJwt = decodeJwtOrThrow(decodedJwt.payload["njwt"]);
+    }
+    if (typeof decodedJwt.payload["zap:acc"] !== "string") {
+        throw new Error("JWT payload does not contain accountId");
+    }
+    const accountId = parseInt(decodedJwt.payload["zap:acc"], 10);
+    if (isNaN(accountId)) {
+        throw new Error("JWT accountId is not a number");
+    }
+    if (decodedJwt.payload["sub_type"] !== "customuser" ||
+        typeof decodedJwt.payload["sub"] !== "string") {
+        throw new Error("JWT payload does not contain customUserId");
+    }
+    const customUserId = parseInt(decodedJwt.payload["sub"], 10);
+    if (isNaN(customUserId)) {
+        throw new Error("JWT customUserId is not a number");
+    }
+    const email = decodedJwt.payload["zap:uname"];
+    if (typeof email !== "string") {
+        throw new Error("JWT payload does not contain email");
+    }
+    return {
+        accountId,
+        customUserId,
+        email,
+    };
+}
+/**
+ * Clears stored login information.
+ */
+function logout(options = {}) {
+    const { onEvent } = options;
+    clearLogin();
+    onEvent?.({
+        type: "auth_logout",
+        payload: { message: "Logged out successfully", operation: "logout" },
+        timestamp: Date.now(),
+    });
+}
+/**
+ * Gets the path to the configuration file.
+ */
+function getConfigPath() {
+    const cfg = getConfig();
+    return cfg.path;
+}

package/dist/functions/getAction/info.d.ts

@@ -3,15 +3,15 @@ export declare const getActionInfo: {
     name: string;
     inputSchema: import("zod").ZodObject<{
         appKey: import("zod").ZodString;
-        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionType: import("zod").ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
         actionKey: import("zod").ZodString;
     }, "strip", import("zod").ZodTypeAny, {
         appKey: string;
-        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
         actionKey: string;
     }, {
         appKey: string;
-        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
         actionKey: string;
     }>;
     implementation: typeof getAction;

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

@@ -2,15 +2,15 @@ import { z } from "zod";
 import type { Action } from "../../types/domain";
 export declare const GetActionSchema: z.ZodObject<{
     appKey: z.ZodString;
-    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
     actionKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
-    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
     actionKey: string;
 }, {
     appKey: string;
-    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
     actionKey: string;
 }>;
 export type GetActionOptions = z.infer<typeof GetActionSchema> & {

package/dist/functions/getAuthentication/index.d.ts

@@ -0,0 +1,13 @@
+import type { Authentication } from "../../types/domain";
+import type { GetAuthenticationOptions } from "./schemas";
+/**
+ * Get a specific authentication by ID
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Authentication ID and API configuration options
+ * @returns Promise<Authentication> - The authentication details
+ * @throws Error if authentication not found or access denied
+ */
+export declare function getAuthentication(options: GetAuthenticationOptions): Promise<Authentication>;

package/dist/functions/getAuthentication/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthentication = getAuthentication;
+const api_1 = require("../../api");
+/**
+ * Get a specific authentication by ID
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Authentication ID and API configuration options
+ * @returns Promise<Authentication> - The authentication details
+ * @throws Error if authentication not found or access denied
+ */
+async function getAuthentication(options) {
+    const { authenticationId } = options;
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    api.requireAuthTo("get authentication");
+    const data = await api.get(`/api/v4/authentications/${authenticationId}/`, {
+        customErrorHandler: (response) => {
+            if (response.status === 401) {
+                return new Error(`Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`);
+            }
+            if (response.status === 403) {
+                return new Error(`Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${response.status})`);
+            }
+            if (response.status === 404) {
+                return new Error(`Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${response.status})`);
+            }
+            return undefined;
+        },
+    });
+    // Coerce title from label if title is missing (API cleanup)
+    return {
+        ...data,
+        title: data.title || data.label || undefined,
+    };
+}

package/dist/functions/getAuthentication/info.d.ts

@@ -0,0 +1,12 @@
+import { getAuthentication } from "./index";
+export declare const getAuthenticationInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        authenticationId: import("zod").ZodNumber;
+    }, "strip", import("zod").ZodTypeAny, {
+        authenticationId: number;
+    }, {
+        authenticationId: number;
+    }>;
+    implementation: typeof getAuthentication;
+};

package/dist/functions/getAuthentication/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthenticationInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.getAuthenticationInfo = {
+    name: index_1.getAuthentication.name,
+    inputSchema: schemas_1.GetAuthenticationSchema,
+    implementation: index_1.getAuthentication,
+};

package/dist/functions/getAuthentication/schemas.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { Authentication } from "../../types/domain";
+export declare const GetAuthenticationSchema: z.ZodObject<{
+    authenticationId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    authenticationId: number;
+}, {
+    authenticationId: number;
+}>;
+export type GetAuthenticationOptions = z.infer<typeof GetAuthenticationSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Function to dynamically resolve authentication token */
+    getToken?: () => Promise<string | undefined>;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface GetAuthenticationSdkFunction {
+    getAuthentication: (options: GetAuthenticationOptions) => Promise<Authentication>;
+}

package/dist/functions/getAuthentication/schemas.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAuthenticationSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../../schema-utils");
+const Auth_1 = require("../../schemas/Auth");
+// Pure Zod schema - no resolver metadata!
+exports.GetAuthenticationSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    authenticationId: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .describe("Authentication ID to retrieve"),
+})
+    .describe("Get a specific authentication by ID"), Auth_1.AuthItemSchema);

package/dist/functions/listActions/info.d.ts

@@ -3,12 +3,12 @@ export declare const listActionsInfo: {
     name: string;
     inputSchema: import("zod").ZodObject<{
         appKey: import("zod").ZodOptional<import("zod").ZodString>;
-        type: import("zod").ZodOptional<import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>>;
     }, "strip", import("zod").ZodTypeAny, {
-        type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        type?: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter" | undefined;
         appKey?: string | undefined;
     }, {
-        type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        type?: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter" | undefined;
         appKey?: string | undefined;
     }>;
     implementation: typeof listActions;

package/dist/functions/listActions/schemas.d.ts

@@ -2,12 +2,12 @@ import { z } from "zod";
 import type { Action } from "../../types/domain";
 export declare const ListActionsSchema: z.ZodObject<{
     appKey: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+    type: z.ZodOptional<z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>>;
 }, "strip", z.ZodTypeAny, {
-    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+    type?: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter" | undefined;
     appKey?: string | undefined;
 }, {
-    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+    type?: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter" | undefined;
     appKey?: string | undefined;
 }>;
 export type ListActionsOptions = z.infer<typeof ListActionsSchema> & {

package/dist/functions/listFields/info.d.ts

@@ -3,19 +3,19 @@ export declare const listFieldsInfo: {
     name: string;
     inputSchema: import("zod").ZodObject<{
         appKey: import("zod").ZodString;
-        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionType: import("zod").ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
         actionKey: import("zod").ZodString;
         authenticationId: import("zod").ZodOptional<import("zod").ZodNumber>;
         params: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
     }, "strip", import("zod").ZodTypeAny, {
         appKey: string;
-        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
         actionKey: string;
         params?: Record<string, any> | undefined;
         authenticationId?: number | undefined;
     }, {
         appKey: string;
-        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
         actionKey: string;
         params?: Record<string, any> | undefined;
         authenticationId?: number | undefined;

package/dist/functions/listFields/schemas.d.ts

@@ -2,19 +2,19 @@ import { z } from "zod";
 import type { ActionField } from "../../types/domain";
 export declare const ListFieldsSchema: z.ZodObject<{
     appKey: z.ZodString;
-    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
     actionKey: z.ZodString;
     authenticationId: z.ZodOptional<z.ZodNumber>;
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
-    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
     actionKey: string;
     params?: Record<string, any> | undefined;
     authenticationId?: number | undefined;
 }, {
     appKey: string;
-    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionType: "read" | "read_bulk" | "write" | "run" | "search" | "search_or_write" | "search_and_write" | "filter";
     actionKey: string;
     params?: Record<string, any> | undefined;
     authenticationId?: number | undefined;