@open-loyalty/mcp-server 1.5.3 → 1.7.0

package/dist/tools/campaign/member-handlers.js

@@ -1,5 +1,5 @@
 import { apiGet, apiPost } from "../../client/http.js";
-import { formatApiError } from "../../utils/errors.js";
+import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
 import { getStoreCode } from "../../config.js";
 // Code management handlers
 export async function campaignGenerateCodes(input) {
@@ -9,6 +9,15 @@ export async function campaignGenerateCodes(input) {
         return { codesGenerated: input.quantity };
     }
     catch (error) {
+        const axiosError = error;
+        if (axiosError.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "NOT_FOUND",
+                message: `Campaign '${input.campaignId}' not found`,
+                hint: "Use ol_campaign_list() to find existing campaigns and their IDs. The campaignId may be incorrect or the campaign may have been deleted.",
+                relatedTool: "ol_campaign_generate_codes",
+            });
+        }
         throw formatApiError(error, "ol_campaign_generate_codes");
     }
 }
@@ -83,6 +92,15 @@ export async function campaignGetAvailable(input) {
         };
     }
     catch (error) {
+        const axiosError = error;
+        if (axiosError.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "NOT_FOUND",
+                message: `Member '${input.memberId}' not found`,
+                hint: "Use ol_member_list() to search for the member by email, name, or phone. The member ID may be incorrect.",
+                relatedTool: "ol_campaign_get_available",
+            });
+        }
         throw formatApiError(error, "ol_campaign_get_available");
     }
 }
@@ -117,6 +135,15 @@ export async function campaignGetVisible(input) {
         };
     }
     catch (error) {
+        const axiosError = error;
+        if (axiosError.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "NOT_FOUND",
+                message: `Member '${input.memberId}' not found`,
+                hint: "Use ol_member_list() to search for the member by email, name, or phone. The member ID may be incorrect.",
+                relatedTool: "ol_campaign_get_visible",
+            });
+        }
         throw formatApiError(error, "ol_campaign_get_visible");
     }
 }
@@ -154,6 +181,15 @@ export async function campaignGetLeaderboard(input) {
         };
     }
     catch (error) {
+        const axiosError = error;
+        if (axiosError.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "NOT_FOUND",
+                message: `Campaign '${input.campaignId}' not found`,
+                hint: "Use ol_campaign_list() to find existing campaigns and their IDs.",
+                relatedTool: "ol_campaign_get_leaderboard",
+            });
+        }
         throw formatApiError(error, "ol_campaign_get_leaderboard");
     }
 }

package/dist/tools/campaign/schemas.js

@@ -18,8 +18,8 @@ const CampaignEffectInputSchema = z.object({
         "Conditional: 'event.body.minutes_before >= 60 ? 25 : 0'. " +
         "BUSINESS IMPACT: 'transaction.grossValue * 10' on $500 avg transaction = 5,000 points/purchase. " +
         "At $0.01/point, that is a 10% return rate. Confirm the formula and earn rate with the user."),
-    walletCode: z.string().optional().describe("Wallet code for points (default wallet if not specified)."),
-    rewardId: z.string().optional().describe("Reward ID (required for give_reward effect)."),
+    walletCode: z.string().optional().describe("Wallet code for points (default wallet if not specified). Use ol_wallet_type_list to find valid codes."),
+    rewardId: z.string().optional().describe("Reward ID (required for give_reward effect). Use ol_reward_list to find valid rewardId values."),
     customAttributeKey: z.string().optional().describe("Custom attribute key (for assign/remove member custom attribute effects)."),
     customAttributeValueRule: z.string().optional().describe("Custom attribute value rule."),
 });
@@ -52,8 +52,8 @@ const CampaignRuleInputSchema = z.object({
 });
 // Activity input schema
 const CampaignActivityInputSchema = z.object({
-    startsAt: z.string().describe("Campaign start date/time (ISO format: YYYY-MM-DD HH:mm+TZ). REQUIRED."),
-    endsAt: z.string().optional().describe("Campaign end date/time (ISO format). " +
+    startsAt: z.string().describe("Campaign start date/time (format: 'YYYY-MM-DD HH:mm+TZ', e.g., '2026-01-01 00:00+00:00'). REQUIRED."),
+    endsAt: z.string().optional().describe("Campaign end date/time (format: 'YYYY-MM-DD HH:mm+TZ', e.g., '2026-12-31 23:59+00:00'). " +
         "BUSINESS IMPACT: If not specified, campaign runs indefinitely -- this is an open-ended budget commitment. " +
         "Confirm with user whether the campaign should have an end date."),
 });
@@ -89,15 +89,15 @@ const CampaignLimitsInputSchema = z.object({
 }).optional();
 // Label input schema
 const CampaignLabelInputSchema = z.object({
-    key: z.string().describe("Label key."),
-    value: z.string().describe("Label value."),
+    key: z.string().describe("Label key (e.g., 'category', 'channel', 'season')."),
+    value: z.string().describe("Label value (e.g., 'electronics', 'online', 'summer')."),
 });
 // Transaction item for simulation
 const SimulateTransactionItemSchema = z.object({
     sku: z.string().describe("Product SKU."),
     name: z.string().describe("Product name."),
-    qty: z.union([z.string(), z.number()]).optional().describe("Item quantity."),
-    grossValue: z.union([z.string(), z.number()]).describe("Item gross value."),
+    qty: z.union([z.string(), z.number()]).optional().describe("Item quantity. Accepts string or number (API is flexible on type)."),
+    grossValue: z.union([z.string(), z.number()]).describe("Item gross value. Accepts string or number (API is flexible on type)."),
     category: z.string().optional().describe("Product category."),
     maker: z.string().optional().describe("Product maker/brand."),
     labels: z.array(z.object({
@@ -120,7 +120,7 @@ const SimulateTransactionSchema = z.object({
 }).optional();
 // Custom event for simulation
 const SimulateCustomEventSchema = z.object({
-    eventCode: z.string().describe("Custom event code (must match campaign trigger event)."),
+    eventCode: z.string().describe("Custom event code (must match campaign trigger event). Use ol_custom_event_schema_list to find valid event codes."),
     attributes: z.record(z.unknown()).optional().describe("Custom event attributes."),
 }).optional();
 // Customer for simulation
@@ -156,7 +156,8 @@ export const CampaignUpdateInputSchema = {
     storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
     campaignId: z.string().describe("The campaign ID (UUID) to update."),
     type: CampaignTypeEnum.describe("Campaign type: direct or referral."),
-    trigger: CampaignTriggerEnum.describe("What triggers the campaign: transaction, custom_event, time, achievement, geolocation, etc."),
+    trigger: CampaignTriggerEnum.describe("What triggers the campaign. Valid values: transaction, custom_event, time, achievement, " +
+        "custom_event_unique_code, leaderboard, internal_event, return_transaction, challenge, fortune_wheel."),
     translations: z.object({
         en: z.object({
             name: z.string().describe("Campaign name in English (REQUIRED)."),
@@ -164,8 +165,8 @@ export const CampaignUpdateInputSchema = {
         }),
     }).passthrough().describe("Translations object with at least 'en' key."),
     activity: z.object({
-        startsAt: z.string().describe("Campaign start date/time (ISO format: YYYY-MM-DD HH:mm+TZ). REQUIRED."),
-        endsAt: z.string().optional().describe("Campaign end date/time (ISO format). If not specified, campaign runs indefinitely."),
+        startsAt: z.string().describe("Campaign start date/time (format: 'YYYY-MM-DD HH:mm+TZ', e.g., '2026-01-01 00:00+00:00'). REQUIRED."),
+        endsAt: z.string().optional().describe("Campaign end date/time (format: 'YYYY-MM-DD HH:mm+TZ', e.g., '2026-12-31 23:59+00:00'). If not specified, campaign runs indefinitely."),
     }).describe("Campaign active period with required startsAt."),
     rules: z.array(z.object({
         name: z.string().describe("Rule name (required)."),
@@ -285,7 +286,8 @@ export const CampaignGetLeaderboardInputSchema = {
 export const CampaignCreateInputSchema = {
     storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
     type: CampaignTypeEnum.describe("Campaign type: direct (standard) or referral (for referral programs)."),
-    trigger: CampaignTriggerEnum.describe("What triggers the campaign: transaction, custom_event, time, achievement, etc."),
+    trigger: CampaignTriggerEnum.describe("What triggers the campaign. Valid values: transaction, custom_event, time, achievement, " +
+        "custom_event_unique_code, leaderboard, internal_event, return_transaction, challenge, fortune_wheel."),
     translations: TranslationsInputSchema,
     activity: CampaignActivityInputSchema.describe("Campaign active period with required startsAt and optional endsAt."),
     rules: z.array(CampaignRuleInputSchema).describe("Array of rules defining when and what effects to apply. Each rule requires a name."),
@@ -300,7 +302,7 @@ export const CampaignCreateInputSchema = {
     active: z.boolean().optional().describe("Whether campaign is active (default: false)."),
     displayOrder: z.number().optional().describe("Display order for sorting campaigns."),
     labels: z.array(CampaignLabelInputSchema).optional().describe("Custom labels/tags for the campaign."),
-    event: z.string().optional().describe("Custom event name (required for custom_event trigger). Must match an existing custom event schema."),
+    event: z.string().optional().describe("Custom event name (required for custom_event trigger). Must match an existing custom event schema. Use ol_custom_event_schema_list to find valid event codes."),
     achievementId: z.string().optional().describe("Achievement ID (required for trigger='achievement'). " +
         "Use achievement_create first, then pass the returned achievementId here to award points/rewards when members complete that achievement."),
 };

package/dist/tools/custom-event/handlers.d.ts

@@ -0,0 +1,98 @@
+interface CustomEventSchemaItem {
+    eventType: string;
+    name: string;
+    schema?: {
+        fields?: Array<{
+            name: string;
+            type: string;
+            description?: string;
+        }>;
+    };
+    active: boolean;
+    createdAt?: string;
+}
+export declare function customEventSchemaList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    eventType?: string;
+    name?: string;
+    active?: boolean;
+}): Promise<{
+    schemas: CustomEventSchemaItem[];
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;
+export declare function customEventSchemaGet(input: {
+    storeCode?: string;
+    eventType: string;
+}): Promise<CustomEventSchemaItem>;
+export declare function customEventSchemaCreate(input: {
+    storeCode?: string;
+    eventType: string;
+    name: string;
+    fields: Array<{
+        name: string;
+        type: string;
+        description?: string;
+    }>;
+    active?: boolean;
+}): Promise<void>;
+interface CustomEventSchemaUpdateInput {
+    storeCode?: string;
+    eventType: string;
+    name: string;
+    fields: Array<{
+        name: string;
+        type: string;
+        description?: string;
+    }>;
+    active?: boolean;
+}
+export declare function customEventSchemaUpdate(input: CustomEventSchemaUpdateInput): Promise<void>;
+export declare function customEventSchemaActivate(input: {
+    storeCode?: string;
+    eventType: string;
+    active: boolean;
+}): Promise<void>;
+interface CustomEventSendInput {
+    storeCode?: string;
+    eventType: string;
+    customerData: {
+        customerId?: string;
+        email?: string;
+        phone?: string;
+        loyaltyCardNumber?: string;
+    };
+    eventDate: string;
+    body?: Record<string, unknown>;
+    eventId?: string;
+}
+export declare function customEventSend(input: CustomEventSendInput): Promise<{
+    customEventId?: string;
+}>;
+interface CustomEventItem {
+    customEventId: string;
+    type: string;
+    customerId?: string;
+    eventDate?: string;
+    body?: Record<string, unknown>;
+    createdAt?: string;
+}
+export declare function customEventList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    type?: string;
+    customerId?: string;
+    email?: string;
+}): Promise<{
+    events: CustomEventItem[];
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;
+export {};

package/dist/tools/custom-event/handlers.js

@@ -0,0 +1,238 @@
+import { apiGet, apiPost, apiPut } from "../../client/http.js";
+import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
+import axios from "axios";
+import { getStoreCode } from "../../config.js";
+export async function customEventSchemaList(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.eventType)
+        params.append("eventType", input.eventType);
+    if (input.name)
+        params.append("name", input.name);
+    if (input.active !== undefined)
+        params.append("active", String(input.active));
+    const queryString = params.toString();
+    const url = `/${storeCode}/customEvent/schema${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const total = response.total || {};
+        return {
+            schemas: response.items || [],
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        if (axios.isAxiosError(error) && error.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "STORE_NOT_FOUND",
+                message: "Cannot list custom event schemas - store not found",
+                hint: "Use ol_store_list() to verify the store code is correct.",
+                relatedTool: "ol_custom_event_schema_list",
+            });
+        }
+        if (axios.isAxiosError(error) && error.response?.status === 403) {
+            throw new OpenLoyaltyError({
+                code: "CUSTOM_EVENT_PERMISSION_DENIED",
+                message: "You don't have permission to view custom event schemas",
+                hint: "Custom event management requires the EVENTS:VIEW permission. Use ol_admin_get_permissions() to check your access.",
+                relatedTool: "ol_custom_event_schema_list",
+            });
+        }
+        throw formatApiError(error, "ol_custom_event_schema_list");
+    }
+}
+export async function customEventSchemaGet(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        const response = await apiGet(`/${storeCode}/customEvent/schema/${input.eventType}`);
+        return response;
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            throw new OpenLoyaltyError({ code: "NOT_FOUND", message: `Custom event schema '${input.eventType}' not found`,
+                hint: "Use ol_custom_event_schema_list() to find existing event schemas.", relatedTool: "ol_custom_event_schema_get" });
+        }
+        throw formatApiError(error, "ol_custom_event_schema_get");
+    }
+}
+export async function customEventSchemaCreate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const schemaPayload = {
+        customEventSchema: {
+            eventType: input.eventType,
+            name: input.name,
+            schema: {
+                fields: input.fields,
+            },
+            active: {
+                isActive: input.active ?? true,
+            },
+        },
+    };
+    try {
+        await apiPost(`/${storeCode}/customEvent/schema`, schemaPayload);
+    }
+    catch (error) {
+        const axiosError = error;
+        const apiErrors = axiosError.response?.data?.errors || [];
+        const allMessages = [
+            axiosError.response?.data?.message || "",
+            ...apiErrors.map(e => e.message)
+        ].join(" ").toLowerCase();
+        if (allMessages.includes("already") || allMessages.includes("duplicate") || allMessages.includes("unique")) {
+            throw new OpenLoyaltyError({
+                code: "DUPLICATE_EVENT_TYPE",
+                message: `Custom event schema '${input.eventType}' already exists`,
+                hint: `Use ol_custom_event_schema_list(eventType: "${input.eventType}") to find the existing schema. Use ol_custom_event_schema_update() to modify it, or choose a different eventType code.`,
+                relatedTool: "ol_custom_event_schema_create",
+            });
+        }
+        throw formatApiError(error, "ol_custom_event_schema_create");
+    }
+}
+export async function customEventSchemaUpdate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const schemaPayload = {
+        customEventSchema: {
+            name: input.name,
+            schema: {
+                fields: input.fields,
+            },
+            active: {
+                isActive: input.active ?? true,
+            },
+        },
+    };
+    try {
+        await apiPut(`/${storeCode}/customEvent/schema/${input.eventType}`, schemaPayload);
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            throw new OpenLoyaltyError({ code: "NOT_FOUND", message: `Custom event schema '${input.eventType}' not found`,
+                hint: "Use ol_custom_event_schema_list() to find existing schemas, or create with ol_custom_event_schema_create().",
+                relatedTool: "ol_custom_event_schema_update" });
+        }
+        throw formatApiError(error, "ol_custom_event_schema_update");
+    }
+}
+export async function customEventSchemaActivate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        await apiPost(`/${storeCode}/customEvent/schema/${input.eventType}/active`, {
+            active: input.active,
+        });
+    }
+    catch (error) {
+        if (error.response?.status === 404) {
+            throw new OpenLoyaltyError({ code: "NOT_FOUND", message: `Custom event schema '${input.eventType}' not found`,
+                hint: "Use ol_custom_event_schema_list() to find existing event schemas.", relatedTool: "ol_custom_event_schema_activate" });
+        }
+        throw formatApiError(error, "ol_custom_event_schema_activate");
+    }
+}
+export async function customEventSend(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const eventPayload = {
+        event: {
+            type: input.eventType,
+            customerData: input.customerData,
+            eventDate: input.eventDate,
+        },
+    };
+    const eventObj = eventPayload.event;
+    if (input.body)
+        eventObj.body = input.body;
+    if (input.eventId)
+        eventObj.eventId = input.eventId;
+    try {
+        const response = await apiPost(`/${storeCode}/customEvent`, eventPayload);
+        return { customEventId: response.customEventId };
+    }
+    catch (error) {
+        const axiosError = error;
+        const apiErrors = axiosError.response?.data?.errors || [];
+        const allMessages = [
+            error instanceof Error ? error.message : "",
+            axiosError.response?.data?.message || "",
+            ...apiErrors.map(e => e.message)
+        ].join(" ").toLowerCase();
+        if (allMessages.includes("schema") && (allMessages.includes("not found") || allMessages.includes("not exist") || allMessages.includes("invalid"))) {
+            throw new OpenLoyaltyError({
+                code: "SCHEMA_NOT_FOUND",
+                message: `Custom event schema '${input.eventType}' not found`,
+                hint: `Use ol_custom_event_schema_list() to find valid event type codes. The eventType must match an existing active schema. You may need to create one with ol_custom_event_schema_create().`,
+                relatedTool: "ol_custom_event_send",
+            });
+        }
+        if (axiosError.response?.status === 404 || (allMessages.includes("event") && allMessages.includes("not found"))) {
+            throw new OpenLoyaltyError({
+                code: "SCHEMA_NOT_FOUND",
+                message: `Custom event type '${input.eventType}' not found or member not found`,
+                hint: `Verify: 1) The eventType '${input.eventType}' exists (use ol_custom_event_schema_list()). 2) The member exists (use ol_member_list() to search).`,
+                relatedTool: "ol_custom_event_send",
+            });
+        }
+        if (allMessages.includes("customer") && (allMessages.includes("not found") || allMessages.includes("not exist"))) {
+            throw new OpenLoyaltyError({
+                code: "MEMBER_NOT_FOUND",
+                message: "The specified member was not found",
+                hint: "Use ol_member_list() to search for the member by email, name, or phone. Verify the customerId, email, phone, or loyaltyCardNumber is correct.",
+                relatedTool: "ol_custom_event_send",
+            });
+        }
+        throw formatApiError(error, "ol_custom_event_send");
+    }
+}
+export async function customEventList(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.type)
+        params.append("type", input.type);
+    if (input.customerId)
+        params.append("customerId", input.customerId);
+    if (input.email)
+        params.append("customerData:email", input.email);
+    const queryString = params.toString();
+    const url = `/${storeCode}/customEvent${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const total = response.total || {};
+        return {
+            events: response.items || [],
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        if (axios.isAxiosError(error) && error.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "STORE_NOT_FOUND",
+                message: "Cannot list custom events - store not found",
+                hint: "Use ol_store_list() to verify the store code is correct.",
+                relatedTool: "ol_custom_event_list",
+            });
+        }
+        if (axios.isAxiosError(error) && error.response?.status === 403) {
+            throw new OpenLoyaltyError({
+                code: "CUSTOM_EVENT_PERMISSION_DENIED",
+                message: "You don't have permission to view custom events",
+                hint: "Custom event access requires the EVENTS:VIEW permission. Use ol_admin_get_permissions() to check your access.",
+                relatedTool: "ol_custom_event_list",
+            });
+        }
+        throw formatApiError(error, "ol_custom_event_list");
+    }
+}

package/dist/tools/custom-event/index.d.ts

@@ -0,0 +1,139 @@
+export { CustomEventSchemaListInputSchema, CustomEventSchemaGetInputSchema, CustomEventSchemaCreateInputSchema, CustomEventSchemaUpdateInputSchema, CustomEventSchemaActivateInputSchema, CustomEventSendInputSchema, CustomEventListInputSchema, } from "./schemas.js";
+export { customEventSchemaList, customEventSchemaGet, customEventSchemaCreate, customEventSchemaUpdate, customEventSchemaActivate, customEventSend, customEventList, } from "./handlers.js";
+import { customEventSchemaList, customEventSchemaGet, customEventSchemaCreate, customEventSchemaUpdate, customEventSchemaActivate, customEventSend, customEventList } from "./handlers.js";
+export declare const customEventToolDefinitions: readonly [{
+    readonly name: "ol_custom_event_schema_list";
+    readonly title: "List Custom Event Schemas";
+    readonly description: string;
+    readonly readOnly: true;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        page: import("zod").ZodOptional<import("zod").ZodNumber>;
+        perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        eventType: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    readonly handler: typeof customEventSchemaList;
+}, {
+    readonly name: "ol_custom_event_schema_get";
+    readonly title: "Get Custom Event Schema";
+    readonly description: "Get details of a specific custom event schema including its fields.";
+    readonly readOnly: true;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        eventType: import("zod").ZodString;
+    };
+    readonly handler: typeof customEventSchemaGet;
+}, {
+    readonly name: "ol_custom_event_schema_create";
+    readonly title: "Create Custom Event Schema";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly idempotent: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        eventType: import("zod").ZodString;
+        name: import("zod").ZodString;
+        fields: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodEnum<["text", "number", "boolean", "datetime"]>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "number" | "boolean" | "text" | "datetime";
+            name: string;
+            description?: string | undefined;
+        }, {
+            type: "number" | "boolean" | "text" | "datetime";
+            name: string;
+            description?: string | undefined;
+        }>, "many">;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    readonly handler: typeof customEventSchemaCreate;
+}, {
+    readonly name: "ol_custom_event_schema_update";
+    readonly title: "Update Custom Event Schema";
+    readonly description: "Update an existing custom event schema (name, fields, active status).";
+    readonly readOnly: false;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        eventType: import("zod").ZodString;
+        name: import("zod").ZodString;
+        fields: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodEnum<["text", "number", "boolean", "datetime"]>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "number" | "boolean" | "text" | "datetime";
+            name: string;
+            description?: string | undefined;
+        }, {
+            type: "number" | "boolean" | "text" | "datetime";
+            name: string;
+            description?: string | undefined;
+        }>, "many">;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    readonly handler: typeof customEventSchemaUpdate;
+}, {
+    readonly name: "ol_custom_event_schema_activate";
+    readonly title: "Activate/Deactivate Custom Event Schema";
+    readonly description: "Activate or deactivate a custom event schema. Inactive schemas won't trigger campaigns/achievements.";
+    readonly readOnly: false;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        eventType: import("zod").ZodString;
+        active: import("zod").ZodBoolean;
+    };
+    readonly handler: typeof customEventSchemaActivate;
+}, {
+    readonly name: "ol_custom_event_send";
+    readonly title: "Send Custom Event";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly idempotent: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        eventType: import("zod").ZodString;
+        customerData: import("zod").ZodObject<{
+            customerId: import("zod").ZodOptional<import("zod").ZodString>;
+            email: import("zod").ZodOptional<import("zod").ZodString>;
+            phone: import("zod").ZodOptional<import("zod").ZodString>;
+            loyaltyCardNumber: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            email?: string | undefined;
+            phone?: string | undefined;
+            loyaltyCardNumber?: string | undefined;
+            customerId?: string | undefined;
+        }, {
+            email?: string | undefined;
+            phone?: string | undefined;
+            loyaltyCardNumber?: string | undefined;
+            customerId?: string | undefined;
+        }>;
+        eventDate: import("zod").ZodString;
+        body: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        eventId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    readonly handler: typeof customEventSend;
+}, {
+    readonly name: "ol_custom_event_list";
+    readonly title: "List Custom Events";
+    readonly description: "List custom events that have been sent. Filter by event type or member to see event history.";
+    readonly readOnly: true;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        page: import("zod").ZodOptional<import("zod").ZodNumber>;
+        perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        type: import("zod").ZodOptional<import("zod").ZodString>;
+        customerId: import("zod").ZodOptional<import("zod").ZodString>;
+        email: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    readonly handler: typeof customEventList;
+}];