@open-loyalty/mcp-server 1.0.0

package/dist/tools/campaign.js

@@ -0,0 +1,724 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiPatch, apiDelete } from "../client/http.js";
+import { CampaignTypeEnum, CampaignTriggerEnum, } from "../types/schemas/campaign.js";
+import { formatApiError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+// Input Schemas
+export const CampaignListInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    active: z.boolean().optional().describe("Filter by active status."),
+    type: CampaignTypeEnum.optional().describe("Filter by campaign type: direct or referral."),
+    trigger: CampaignTriggerEnum.optional().describe("Filter by trigger type: transaction, custom_event, time, etc."),
+};
+// Translations schema for campaign input
+const TranslationsInputSchema = z.object({
+    en: z.object({
+        name: z.string().describe("Campaign name in English."),
+        description: z.string().optional().describe("Campaign description in English."),
+    }),
+}).passthrough().describe("Translations object with at least 'en' key. Other languages (pl, de, etc.) are optional.");
+// Effect input schema
+const CampaignEffectInputSchema = z.object({
+    effect: z.enum(["give_points", "give_reward", "deduct_unit", "assign_member_custom_attribute", "remove_member_custom_attribute"]).describe("Effect type: give_points, give_reward, deduct_unit, etc."),
+    pointsRule: z.object({
+        expression: z.string().optional().describe("Expression to calculate points (e.g., 'transaction.grossValue * 10')."),
+        multiplier: z.number().optional().describe("Points multiplier."),
+        fixedValue: z.number().optional().describe("Fixed points value."),
+    }).optional().describe("Points calculation rule (required for give_points effect)."),
+    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)."),
+    customAttributeKey: z.string().optional().describe("Custom attribute key (for assign/remove member custom attribute effects)."),
+    customAttributeValueRule: z.string().optional().describe("Custom attribute value rule."),
+});
+// Condition input schema
+const CampaignConditionInputSchema = z.object({
+    operator: z.string().describe("Condition operator (is_equal, gte, lte, etc.)."),
+    attribute: z.string().describe("Attribute to check."),
+    data: z.record(z.unknown()).optional().describe("Condition-specific data."),
+});
+// Rule input schema
+const CampaignRuleInputSchema = z.object({
+    name: z.string().describe("Rule name."),
+    description: z.string().optional().describe("Rule description."),
+    target: z.enum(["self", "referrer"]).optional().describe("Target for rule effects: self (default) or referrer."),
+    effects: z.array(CampaignEffectInputSchema).describe("Array of effects to apply when rule matches."),
+    conditions: z.array(CampaignConditionInputSchema).optional().describe("Array of conditions that must match for rule to apply."),
+});
+// Activity input schema
+const CampaignActivityInputSchema = z.object({
+    startsAt: z.string().describe("Campaign start date/time (ISO format: YYYY-MM-DD HH:mm+TZ)."),
+    endsAt: z.string().optional().describe("Campaign end date/time (ISO format). If not specified, campaign runs indefinitely."),
+});
+// Visibility input schema
+const CampaignVisibilityInputSchema = z.object({
+    target: z.enum(["all", "tier", "segment"]).describe("Who can see the campaign: all, tier (specific tiers), or segment (specific segments)."),
+    tiers: z.array(z.string()).optional().describe("Array of tier level IDs (required if target is 'tier')."),
+    segments: z.array(z.string()).optional().describe("Array of segment IDs (required if target is 'segment')."),
+}).optional();
+// Audience input schema
+const CampaignAudienceInputSchema = z.object({
+    target: z.enum(["all", "tier", "segment"]).describe("Who can participate: all, tier (specific tiers), or segment (specific segments)."),
+    tiers: z.array(z.string()).optional().describe("Array of tier level IDs."),
+    segments: z.array(z.string()).optional().describe("Array of segment IDs."),
+}).optional();
+// Limit value input schema
+const CampaignLimitValueInputSchema = z.object({
+    value: z.number().describe("Limit value."),
+    interval: z.object({
+        type: z.enum(["days", "weeks", "months", "years", "forever"]).describe("Interval type."),
+        value: z.number().optional().describe("Interval value (not needed for 'forever')."),
+    }).optional().describe("Time interval for the limit."),
+});
+// Limits input schema
+const CampaignLimitsInputSchema = z.object({
+    points: CampaignLimitValueInputSchema.optional().describe("Total points limit for the campaign."),
+    pointsPerMember: CampaignLimitValueInputSchema.optional().describe("Points limit per member."),
+    executionsPerMember: CampaignLimitValueInputSchema.optional().describe("Execution limit per member."),
+}).optional();
+// Label input schema
+const CampaignLabelInputSchema = z.object({
+    key: z.string().describe("Label key."),
+    value: z.string().describe("Label value."),
+});
+export const CampaignGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    campaignId: z.string().describe("The campaign ID (UUID) to retrieve."),
+};
+export const CampaignUpdateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    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."),
+    translations: z.object({
+        en: z.object({
+            name: z.string(),
+            description: z.string().optional(),
+        }),
+    }).passthrough().describe("Translations object with at least 'en' key."),
+    activity: z.object({
+        startsAt: z.string(),
+        endsAt: z.string().optional(),
+    }).describe("Campaign active period."),
+    rules: z.array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        target: z.enum(["self", "referrer"]).optional(),
+        effects: z.array(z.object({
+            effect: z.string(),
+            pointsRule: z.record(z.unknown()).optional(),
+            walletCode: z.string().optional(),
+            rewardId: z.string().optional(),
+        })),
+        conditions: z.array(z.object({
+            operator: z.string(),
+            attribute: z.string(),
+            data: z.record(z.unknown()).optional(),
+        })).optional(),
+    })).describe("Campaign rules."),
+    visibility: z.object({
+        target: z.enum(["all", "tier", "segment"]),
+        tiers: z.array(z.string()).optional(),
+        segments: z.array(z.string()).optional(),
+    }).optional(),
+    audience: z.object({
+        target: z.enum(["all", "tier", "segment"]),
+        tiers: z.array(z.string()).optional(),
+        segments: z.array(z.string()).optional(),
+    }).optional(),
+    limits: z.object({
+        points: z.object({ value: z.number(), interval: z.record(z.unknown()).optional() }).optional(),
+        pointsPerMember: z.object({ value: z.number(), interval: z.record(z.unknown()).optional() }).optional(),
+        executionsPerMember: z.object({ value: z.number(), interval: z.record(z.unknown()).optional() }).optional(),
+    }).optional(),
+    active: z.boolean().optional(),
+    displayOrder: z.number().optional(),
+    labels: z.array(z.object({ key: z.string(), value: z.string() })).optional(),
+    event: z.string().optional(),
+};
+export const CampaignPatchInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    campaignId: z.string().describe("The campaign ID (UUID) to patch."),
+    active: z.boolean().optional().describe("Set campaign active status."),
+    displayOrder: z.number().optional().describe("Set campaign display order."),
+};
+export const CampaignDeleteInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    campaignId: z.string().describe("The campaign ID (UUID) to delete."),
+};
+// 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."),
+    category: z.string().optional().describe("Product category."),
+    maker: z.string().optional().describe("Product maker/brand."),
+    labels: z.array(z.object({
+        key: z.string(),
+        value: z.string(),
+    })).optional().describe("Custom labels."),
+});
+// Transaction for simulation
+const SimulateTransactionSchema = z.object({
+    grossValue: z.number().optional().describe("Total transaction gross value (alternative to items)."),
+    documentNumber: z.string().optional().describe("Document number."),
+    purchasedAt: z.string().optional().describe("Purchase date/time (ISO format)."),
+    documentType: z.enum(["sell", "return"]).optional().describe("Document type."),
+    purchasePlace: z.string().optional().describe("Purchase location."),
+    items: z.array(SimulateTransactionItemSchema).optional().describe("Transaction items."),
+    labels: z.array(z.object({
+        key: z.string(),
+        value: z.string(),
+    })).optional().describe("Custom labels."),
+}).optional();
+// Custom event for simulation
+const SimulateCustomEventSchema = z.object({
+    eventCode: z.string().describe("Custom event code (must match campaign trigger event)."),
+    attributes: z.record(z.unknown()).optional().describe("Custom event attributes."),
+}).optional();
+// Customer for simulation
+const SimulateCustomerSchema = z.object({
+    customerId: z.string().optional().describe("Member ID (UUID) for explicit member matching."),
+    id: z.string().optional().describe("Member ID (UUID) - alias for customerId."),
+    email: z.string().optional().describe("Email for member matching."),
+    loyaltyCardNumber: z.string().optional().describe("Loyalty card for member matching."),
+    phone: z.string().optional().describe("Phone for member matching."),
+    firstName: z.string().optional().describe("Customer first name."),
+    lastName: z.string().optional().describe("Customer last name."),
+});
+// Referrer for simulation (referral campaigns)
+const SimulateReferrerSchema = z.object({
+    id: z.string().optional().describe("Referrer member ID."),
+    email: z.string().optional().describe("Referrer email."),
+    loyaltyCardNumber: z.string().optional().describe("Referrer loyalty card number."),
+}).optional();
+export const CampaignSimulateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    trigger: CampaignTriggerEnum.describe("Campaign trigger type to simulate: transaction, custom_event, etc."),
+    transaction: SimulateTransactionSchema.describe("Transaction data (required for transaction trigger)."),
+    customEvent: SimulateCustomEventSchema.describe("Custom event data (required for custom_event trigger)."),
+    customer: SimulateCustomerSchema.describe("Customer/member data for simulation."),
+    referrer: SimulateReferrerSchema.describe("Referrer data for referral campaigns."),
+};
+export const CampaignGenerateCodesInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    campaignId: z.string().describe("The campaign ID (UUID) to generate codes for."),
+    quantity: z.number().min(1).describe("Number of codes to generate."),
+};
+export const CampaignListCodesInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    campaignId: z.string().describe("The campaign ID (UUID) to list codes for."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    status: z.string().optional().describe("Filter by code status (e.g., 'active', 'used')."),
+    code: z.string().optional().describe("Filter by specific code."),
+};
+export const CampaignGetAvailableInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    memberId: z.string().describe("The member ID (UUID) to get available campaigns for."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    type: CampaignTypeEnum.optional().describe("Filter by campaign type."),
+    trigger: CampaignTriggerEnum.optional().describe("Filter by campaign trigger."),
+};
+export const CampaignGetVisibleInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    memberId: z.string().describe("The member ID (UUID) to get visible campaigns for."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    active: z.boolean().optional().describe("Filter by active status."),
+};
+export const CampaignGetLeaderboardInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    campaignId: z.string().describe("The campaign ID (UUID) to get leaderboard for."),
+    type: z.string().optional().describe("Cycle type for ranking (e.g., 'weekly', 'monthly')."),
+};
+export const CampaignCreateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    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."),
+    translations: TranslationsInputSchema,
+    activity: CampaignActivityInputSchema.describe("Campaign active period with startsAt and optional endsAt."),
+    rules: z.array(CampaignRuleInputSchema).describe("Array of rules defining when and what effects to apply."),
+    visibility: CampaignVisibilityInputSchema.describe("Who can see the campaign."),
+    audience: CampaignAudienceInputSchema.describe("Who can participate in the campaign."),
+    limits: CampaignLimitsInputSchema.describe("Campaign limits for points and executions."),
+    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)."),
+};
+// Handler functions
+export async function campaignList(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.active !== undefined)
+        params.append("active", String(input.active));
+    if (input.type)
+        params.append("type", input.type);
+    if (input.trigger)
+        params.append("trigger", input.trigger);
+    const queryString = params.toString();
+    const url = `/${storeCode}/campaign${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const campaigns = (response.items || []).map((item) => {
+            const campaign = item;
+            const translations = campaign.translations;
+            // Handle both object and array translations format
+            let name = "";
+            if (Array.isArray(translations)) {
+                const enTranslation = translations.find((t) => t.locale === "en" || t.locale?.startsWith("en"));
+                name = enTranslation?.name || translations[0]?.name || campaign.name || "";
+            }
+            else if (translations && typeof translations === "object") {
+                name = translations.en?.name || campaign.name || "";
+            }
+            else {
+                name = campaign.name || "";
+            }
+            return {
+                campaignId: campaign.campaignId,
+                name,
+                type: campaign.type,
+                trigger: campaign.trigger,
+                active: (campaign.active ?? false),
+                displayOrder: campaign.displayOrder,
+            };
+        });
+        const total = response.total || {};
+        return {
+            campaigns,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_list");
+    }
+}
+export async function campaignGet(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/campaign/${input.campaignId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_get");
+    }
+}
+export async function campaignUpdate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const campaignId = input.campaignId;
+    // Build campaign payload excluding storeCode and campaignId
+    const { storeCode: _sc, campaignId: _cid, ...campaignPayload } = input;
+    try {
+        // CRITICAL: Wrap body as { campaign: {...} }
+        await apiPut(`/${storeCode}/campaign/${campaignId}`, { campaign: campaignPayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_update");
+    }
+}
+export async function campaignPatch(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const patchPayload = {};
+    if (input.active !== undefined)
+        patchPayload.active = input.active;
+    if (input.displayOrder !== undefined)
+        patchPayload.displayOrder = input.displayOrder;
+    try {
+        await apiPatch(`/${storeCode}/campaign/${input.campaignId}`, { campaign: patchPayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_patch");
+    }
+}
+export async function campaignDelete(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        await apiDelete(`/${storeCode}/campaign/${input.campaignId}`);
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_delete");
+    }
+}
+export async function campaignSimulate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    // Build the simulate payload
+    const simulatePayload = {
+        trigger: input.trigger,
+        customer: {},
+    };
+    // Build customer object
+    const customer = {};
+    if (input.customer.customerId)
+        customer.id = input.customer.customerId;
+    if (input.customer.id)
+        customer.id = input.customer.id;
+    if (input.customer.email)
+        customer.email = input.customer.email;
+    if (input.customer.loyaltyCardNumber)
+        customer.loyaltyCardNumber = input.customer.loyaltyCardNumber;
+    if (input.customer.phone)
+        customer.phone = input.customer.phone;
+    if (input.customer.firstName)
+        customer.firstName = input.customer.firstName;
+    if (input.customer.lastName)
+        customer.lastName = input.customer.lastName;
+    simulatePayload.customer = customer;
+    // Add transaction if provided
+    if (input.transaction) {
+        const transaction = {};
+        if (input.transaction.grossValue !== undefined)
+            transaction.grossValue = input.transaction.grossValue;
+        if (input.transaction.documentNumber)
+            transaction.documentNumber = input.transaction.documentNumber;
+        if (input.transaction.purchasedAt)
+            transaction.purchasedAt = input.transaction.purchasedAt;
+        if (input.transaction.documentType)
+            transaction.documentType = input.transaction.documentType;
+        if (input.transaction.purchasePlace)
+            transaction.purchasePlace = input.transaction.purchasePlace;
+        if (input.transaction.items)
+            transaction.items = input.transaction.items;
+        if (input.transaction.labels)
+            transaction.labels = input.transaction.labels;
+        simulatePayload.transaction = transaction;
+    }
+    // Add custom event if provided (for custom_event trigger)
+    if (input.customEvent) {
+        simulatePayload.event = input.customEvent.eventCode;
+        if (input.customEvent.attributes) {
+            simulatePayload.eventAttributes = input.customEvent.attributes;
+        }
+    }
+    // Add referrer if provided (for referral campaigns)
+    if (input.referrer) {
+        const referrer = {};
+        if (input.referrer.id)
+            referrer.id = input.referrer.id;
+        if (input.referrer.email)
+            referrer.email = input.referrer.email;
+        if (input.referrer.loyaltyCardNumber)
+            referrer.loyaltyCardNumber = input.referrer.loyaltyCardNumber;
+        simulatePayload.referrer = referrer;
+    }
+    try {
+        // CRITICAL: Wrap body as { simulate: {...} }
+        const response = await apiPost(`/${storeCode}/campaign/simulate`, { simulate: simulatePayload });
+        // Transform effects into simulated effects grouped by campaign
+        const effectsByCampaign = new Map();
+        for (const effect of response.effects || []) {
+            const campaignId = effect.campaign?.campaignId || "unknown";
+            const campaignName = effect.campaign?.name || undefined;
+            if (!effectsByCampaign.has(campaignId)) {
+                effectsByCampaign.set(campaignId, {
+                    campaignId,
+                    campaignName,
+                    effects: [],
+                });
+            }
+            const campaignEffect = effectsByCampaign.get(campaignId);
+            campaignEffect.effects.push({
+                type: effect.type,
+                target: effect.target,
+                points: effect.points,
+                wallet: effect.wallet,
+                rewardId: effect.rewardId,
+            });
+        }
+        return {
+            simulatedEffects: Array.from(effectsByCampaign.values()),
+            evaluationWarnings: response.evaluationWarnings,
+            simulatedMember: response.simulatedMember,
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_simulate");
+    }
+}
+export async function campaignGenerateCodes(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        // Body wrapped as { generate: { numberOfCodes } }
+        await apiPost(`/${storeCode}/campaign/${input.campaignId}/codes/generate`, { generate: { numberOfCodes: input.quantity } });
+        // API returns 204 No Content, so we return the requested quantity
+        return { codesGenerated: input.quantity };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_generate_codes");
+    }
+}
+export async function campaignListCodes(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.status)
+        params.append("status", input.status);
+    if (input.code)
+        params.append("code", input.code);
+    const queryString = params.toString();
+    const url = `/${storeCode}/campaign/${input.campaignId}/codes${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const codes = (response.items || []).map((item) => ({
+            codeId: item.codeId,
+            code: item.code,
+            status: item.status,
+            usedAt: item.usedAt,
+            createdAt: item.createdAt,
+            createdBy: item.createdBy,
+        }));
+        const total = response.total || {};
+        return {
+            codes,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_list_codes");
+    }
+}
+export async function campaignGetAvailable(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    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.trigger)
+        params.append("trigger", input.trigger);
+    const queryString = params.toString();
+    const url = `/${storeCode}/member/${input.memberId}/campaign${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const campaigns = (response.items || []).map((item) => ({
+            campaignId: item.campaignId,
+            name: item.name,
+            active: item.active,
+            type: item.type,
+            trigger: item.trigger,
+            limitReached: item.limitReached,
+            description: item.description,
+        }));
+        const total = response.total || {};
+        return {
+            campaigns,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_get_available");
+    }
+}
+export async function campaignGetVisible(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.active !== undefined)
+        params.append("active", String(input.active));
+    const queryString = params.toString();
+    const url = `/${storeCode}/member/${input.memberId}/campaign/visible${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const campaigns = (response.items || []).map((item) => ({
+            campaignId: item.campaignId,
+            name: item.name,
+            active: item.active,
+            type: item.type,
+            trigger: item.trigger,
+            description: item.description,
+        }));
+        const total = response.total || {};
+        return {
+            campaigns,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_get_visible");
+    }
+}
+export async function campaignGetLeaderboard(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const params = new URLSearchParams();
+    if (input.type)
+        params.append("type", input.type);
+    const queryString = params.toString();
+    const url = `/${storeCode}/campaign/${input.campaignId}/leaderboard${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const entries = (response.items || []).map((item) => ({
+            member: {
+                customerId: item.member.customerId,
+                firstName: item.member.firstName,
+                lastName: item.member.lastName,
+                email: item.member.email,
+                loyaltyCardNumber: item.member.loyaltyCardNumber,
+            },
+            ranking: {
+                score: item.ranking.score,
+                position: item.ranking.position,
+                recalculatedAt: item.ranking.recalculatedAt,
+                changedPositionAt: item.ranking.changedPositionAt,
+            },
+        }));
+        const total = response.total || {};
+        return {
+            entries,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_get_leaderboard");
+    }
+}
+export async function campaignCreate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    // Build the campaign payload
+    const campaignPayload = {
+        type: input.type,
+        trigger: input.trigger,
+        translations: input.translations,
+        activity: input.activity,
+        rules: input.rules,
+    };
+    if (input.visibility)
+        campaignPayload.visibility = input.visibility;
+    if (input.audience)
+        campaignPayload.audience = input.audience;
+    if (input.limits)
+        campaignPayload.limits = input.limits;
+    if (input.active !== undefined)
+        campaignPayload.active = input.active;
+    if (input.displayOrder !== undefined)
+        campaignPayload.displayOrder = input.displayOrder;
+    if (input.labels)
+        campaignPayload.labels = input.labels;
+    if (input.event)
+        campaignPayload.event = input.event;
+    try {
+        // CRITICAL: Wrap body as { campaign: {...} }
+        const response = await apiPost(`/${storeCode}/campaign`, { campaign: campaignPayload });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_campaign_create");
+    }
+}
+// Tool definitions
+export const campaignToolDefinitions = [
+    {
+        name: "openloyalty_campaign_list",
+        description: "List all campaigns. Filter by type (direct/referral) or trigger (transaction/custom_event/time/etc). Use campaign_get for full configuration including rules and effects.",
+        inputSchema: CampaignListInputSchema,
+        handler: campaignList,
+    },
+    {
+        name: "openloyalty_campaign_create",
+        description: "Create campaign to automate engagement. Triggers: transaction (purchase-based), custom_event (for custom actions), time (scheduled). Effects: give_points, give_reward, deduct_unit. Rules define when/what happens. Example - Double points: trigger=transaction, effect=give_points with pointsRule containing multiplier:2.",
+        inputSchema: CampaignCreateInputSchema,
+        handler: campaignCreate,
+    },
+    {
+        name: "openloyalty_campaign_get",
+        description: "Get full campaign configuration including all rules, conditions, effects, and targeting.",
+        inputSchema: CampaignGetInputSchema,
+        handler: campaignGet,
+    },
+    {
+        name: "openloyalty_campaign_update",
+        description: "Full update of campaign configuration. Requires all campaign fields. Use campaign_get first to retrieve current configuration, modify it, then send the complete object.",
+        inputSchema: CampaignUpdateInputSchema,
+        handler: campaignUpdate,
+    },
+    {
+        name: "openloyalty_campaign_patch",
+        description: "Partial update of campaign - only active status and displayOrder can be patched. For full updates, use campaign_update.",
+        inputSchema: CampaignPatchInputSchema,
+        handler: campaignPatch,
+    },
+    {
+        name: "openloyalty_campaign_delete",
+        description: "Permanently delete a campaign. This cannot be undone. Consider deactivating instead if you may need the campaign later.",
+        inputSchema: CampaignDeleteInputSchema,
+        handler: campaignDelete,
+    },
+    {
+        name: "openloyalty_campaign_simulate",
+        description: "Simulate campaign effects without executing them. Use to preview what points/rewards a transaction would earn. Provide trigger type, transaction/event data, and customer. Returns simulated effects grouped by campaign.",
+        inputSchema: CampaignSimulateInputSchema,
+        handler: campaignSimulate,
+    },
+    {
+        name: "openloyalty_campaign_generate_codes",
+        description: "Generate unique redemption codes for a campaign. Use for promotions requiring unique codes. Codes are auto-generated and can be retrieved with campaign_list_codes.",
+        inputSchema: CampaignGenerateCodesInputSchema,
+        handler: campaignGenerateCodes,
+    },
+    {
+        name: "openloyalty_campaign_list_codes",
+        description: "List redemption codes for a campaign. Filter by status (active/used) or specific code. Returns code details including usage status.",
+        inputSchema: CampaignListCodesInputSchema,
+        handler: campaignListCodes,
+    },
+    {
+        name: "openloyalty_campaign_get_available",
+        description: "Get campaigns available to a specific member. Returns campaigns the member can participate in based on their tier, segments, and campaign targeting rules. Includes limitReached indicator.",
+        inputSchema: CampaignGetAvailableInputSchema,
+        handler: campaignGetAvailable,
+    },
+    {
+        name: "openloyalty_campaign_get_visible",
+        description: "Get campaigns visible to a specific member. May include campaigns not yet available (e.g., upcoming campaigns or those requiring certain conditions). Use get_available for campaigns the member can currently participate in.",
+        inputSchema: CampaignGetVisibleInputSchema,
+        handler: campaignGetVisible,
+    },
+    {
+        name: "openloyalty_campaign_get_leaderboard",
+        description: "Get leaderboard rankings for a campaign. Returns ranked list of members with scores and positions. Use for leaderboard-type campaigns to show competition standings.",
+        inputSchema: CampaignGetLeaderboardInputSchema,
+        handler: campaignGetLeaderboard,
+    },
+];