@open-loyalty/mcp-server 1.1.0 → 1.3.3

package/dist/types/schemas/wallet-type.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 export const WalletTypeSchema = z.object({
     walletTypeId: z.string(),
     code: z.string(),
-    name: z.string(),
+    name: z.string().optional(), // Optional: single wallet type endpoint may not return name
     unitSingularName: z.string().optional(),
     unitPluralName: z.string().optional(),
     active: z.boolean(),
@@ -10,8 +10,89 @@ export const WalletTypeSchema = z.object({
     createdAt: z.string().optional(),
     limits: z.record(z.unknown()).optional(),
     allowNegativeBalance: z.boolean().optional(),
+    translations: z.record(z.unknown()).optional(),
+    unitDaysExpiryAfter: z.string().optional(),
+    unitDaysActiveCount: z.number().optional(),
+    unitYearsActiveCount: z.number().optional(),
+    unitDaysLocked: z.number().optional(),
+    allTimeNotLocked: z.boolean().optional(),
+    unitExpiryDate: z.string().optional(),
 });
 // API returns { items: [...] } not just an array
 export const WalletTypeListResponseSchema = z.object({
     items: z.array(WalletTypeSchema),
 });
+// Create response schema - API returns { walletTypeId: "..." }
+export const WalletTypeCreateResponseSchema = z.object({
+    walletTypeId: z.string(),
+});
+// =============================================================================
+// INPUT SCHEMAS (for MCP tool definitions)
+// =============================================================================
+export const WalletTypeListInputSchema = {
+    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
+};
+export const WalletTypeGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
+    walletTypeId: z.string().describe("The wallet type ID (UUID) to retrieve."),
+};
+// Translations schema for wallet types
+const WalletTypeTranslationsInputSchema = z.object({
+    en: z.object({
+        name: z.string().describe("Wallet type name in English (REQUIRED)."),
+        description: z.string().optional().describe("Description in English (optional)."),
+    }),
+}).passthrough().describe("Translations object with at least 'en' key containing { name }.");
+// Limits interval schema
+const LimitsIntervalSchema = z.object({
+    type: z.enum(["calendarHours", "calendarDays", "calendarWeeks", "calendarMonths", "calendarYears"]).describe("Interval type. IMPORTANT: Use 'calendarDays' NOT 'days', 'calendarMonths' NOT 'months', etc."),
+    value: z.number().int().positive().describe("Interval value (e.g., 1 for 'every 1 calendarMonth')."),
+});
+// Points limit schema
+const PointsLimitSchema = z.object({
+    interval: LimitsIntervalSchema.optional().describe("Interval for limit reset. Omit for lifetime/forever limits."),
+    value: z.number().int().nonnegative().describe("Maximum points value for this limit."),
+}).optional();
+// Limits schema
+export const WalletTypeLimitsInputSchema = z.object({
+    points: PointsLimitSchema.describe("Global points limit across all members. Example: { interval: { type: 'calendarYears', value: 1 }, value: 100000 }"),
+    pointsPerMember: PointsLimitSchema.describe("Per-member points limit. Example: { interval: { type: 'calendarYears', value: 1 }, value: 10000 }"),
+}).optional();
+export const WalletTypeCreateInputSchema = {
+    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
+    translations: WalletTypeTranslationsInputSchema.describe("Translations with at least 'en' key containing { name }. REQUIRED."),
+    unitSingularName: z.string().describe("Singular unit name (e.g., 'point', 'coin', 'star'). REQUIRED."),
+    unitPluralName: z.string().describe("Plural unit name (e.g., 'points', 'coins', 'stars'). REQUIRED."),
+    unitDaysExpiryAfter: z.string().describe("⚠️ REQUIRED. Days after earning before points expire. Use 'all_time_active' for never-expiring points, " +
+        "or a number string like '365' for points that expire 365 days after earning."),
+    code: z.string().optional().describe("Unique code for the wallet type (e.g., 'bonus_points', 'store_credit'). " +
+        "Use lowercase with underscores. If not provided, a code will be auto-generated. " +
+        "IMPORTANT: Cannot be changed after creation."),
+    allowNegativeBalance: z.boolean().optional().describe("Whether to allow negative balances (default: false). " +
+        "Set to true for credit-like systems where members can owe points."),
+    unitExpiryDate: z.string().optional().describe("Annual expiry date in 'MM-DD' format (e.g., '12-31' for end of year). " +
+        "Points earned during the year expire on this date. " +
+        "IMPORTANT: Use 'MM-DD' format, NOT 'YYYY-MM-DD'."),
+    unitDaysActiveCount: z.number().int().nonnegative().optional().describe("Number of days points remain active after earning. Use with unitDaysExpiryAfter."),
+    unitYearsActiveCount: z.number().int().nonnegative().optional().describe("Number of years points remain active after earning."),
+    unitDaysLocked: z.number().int().nonnegative().optional().describe("Number of days points are locked after earning before becoming spendable. " +
+        "Use 0 or omit for immediately available points."),
+    allTimeNotLocked: z.boolean().optional().describe("If true, points are never locked and immediately available. Overrides unitDaysLocked."),
+};
+export const WalletTypeUpdateInputSchema = {
+    storeCode: z.string().optional().describe("Store code for multi-tenant routing. DO NOT pass this parameter - the configured default will be used automatically. Only provide a value if the user explicitly asks to work with a different store."),
+    walletTypeId: z.string().describe("The wallet type ID (UUID) to update."),
+    name: z.string().optional().describe("Update the wallet type name (updates translations.en.name)."),
+    description: z.string().optional().describe("Update the description (updates translations.en.description)."),
+    unitSingularName: z.string().optional().describe("Update the singular unit name."),
+    unitPluralName: z.string().optional().describe("Update the plural unit name."),
+    active: z.boolean().optional().describe("Update active status."),
+    allowNegativeBalance: z.boolean().optional().describe("Update negative balance setting."),
+    limits: WalletTypeLimitsInputSchema.describe("Update points limits."),
+    unitExpiryDate: z.string().optional().describe("Update annual expiry date ('MM-DD' format)."),
+    unitDaysExpiryAfter: z.string().optional().describe("Update days until expiry or 'all_time_active'."),
+    unitDaysActiveCount: z.number().int().nonnegative().optional().describe("Update days active count."),
+    unitYearsActiveCount: z.number().int().nonnegative().optional().describe("Update years active count."),
+    unitDaysLocked: z.number().int().nonnegative().optional().describe("Update locked days."),
+    allTimeNotLocked: z.boolean().optional().describe("Update not-locked setting."),
+};

package/dist/utils/errors.js

@@ -1,4 +1,4 @@
-import { AxiosError } from "axios";
+import axios from "axios";
 export class OpenLoyaltyError extends Error {
     code;
     hint;
@@ -15,7 +15,7 @@ export function formatApiError(error, relatedTool) {
     if (error instanceof OpenLoyaltyError) {
         return error;
     }
-    if (error instanceof AxiosError) {
+    if (axios.isAxiosError(error)) {
         const status = error.response?.status;
         const data = error.response?.data;
         if (status === 404) {
@@ -31,6 +31,35 @@ export function formatApiError(error, relatedTool) {
         if (status === 400) {
             const errors = data?.errors;
             const errorDetails = errors?.map(e => `${e.path || ''}: ${e.message}`).join('; ') || '';
+            const fullMessage = data?.message
+                ? `${String(data.message)}${errorDetails ? ` (${errorDetails})` : ''}`
+                : "Invalid request data";
+            // Parse "extra fields" errors - usually means a field shouldn't be at top level
+            if (fullMessage.includes("extra fields") || fullMessage.includes("should not contain extra fields")) {
+                return new OpenLoyaltyError({
+                    code: "VALIDATION_ERROR",
+                    message: fullMessage,
+                    hint: "The API rejected unexpected fields in your request. Common causes: " +
+                        "1. A field name is misspelled, " +
+                        "2. A field should be nested differently (e.g., badgeTypeId may not be supported at creation time), " +
+                        "3. The field isn't supported for this endpoint. " +
+                        "Try removing optional fields and adding them back one at a time to identify the problematic field.",
+                    relatedTool,
+                });
+            }
+            // Parse "selected choice is invalid" errors - enum value mismatch
+            if (fullMessage.includes("selected choice is invalid") || fullMessage.includes("The selected choice is invalid")) {
+                return new OpenLoyaltyError({
+                    code: "VALIDATION_ERROR",
+                    message: fullMessage,
+                    hint: "An enum value is invalid. Common fixes: " +
+                        "1. For interval types, use 'calendarDays' (not 'days'), 'calendarWeeks', 'calendarMonths', 'calendarYears'. " +
+                        "2. For period types, use 'day' (not 'days'), 'week', 'month', 'year'. " +
+                        "3. For trigger types, check the tool description for valid options. " +
+                        "4. Omit interval entirely for lifetime/forever limits.",
+                    relatedTool,
+                });
+            }
             // If API returns "Validation failed" with no details, it's likely an MCP implementation bug
             const hasNoDetails = !errorDetails && data?.message === "Validation failed";
             const hint = hasNoDetails
@@ -38,9 +67,7 @@ export function formatApiError(error, relatedTool) {
                 : "Check the input parameters match the expected format";
             return new OpenLoyaltyError({
                 code: "VALIDATION_ERROR",
-                message: data?.message
-                    ? `${String(data.message)}${errorDetails ? ` (${errorDetails})` : ''}`
-                    : "Invalid request data",
+                message: fullMessage,
                 hint,
                 relatedTool,
             });

package/dist/workflows/app-login-streak.d.ts

@@ -0,0 +1,39 @@
+/**
+ * App Login Streak Workflow
+ *
+ * Creates a campaign to reward fans for daily app logins,
+ * with achievements for consecutive login streaks.
+ */
+export interface AppLoginStreakConfig {
+    /** Coins awarded per daily login */
+    coinsPerLogin: number;
+    /** Whether to create streak bonus achievement */
+    createStreakBonus: boolean;
+    /** Number of consecutive days for streak achievement */
+    streakDays: number;
+    /** Bonus coins for completing the streak */
+    streakBonus: number;
+    /** Badge name for streak achievement (optional) */
+    badgeName?: string;
+    /** Season start date (ISO format) */
+    seasonStart: string;
+    /** Season end date (ISO format) */
+    seasonEnd: string;
+}
+export interface AppLoginStreakResult {
+    success: boolean;
+    loginCampaignId?: string;
+    streakAchievementId?: string;
+    streakBonusCampaignId?: string;
+    errors: string[];
+    summary: string;
+}
+/**
+ * Execute the app login streak workflow
+ */
+export declare function executeAppLoginStreakWorkflow(config?: Partial<AppLoginStreakConfig>): Promise<AppLoginStreakResult>;
+export declare const appLoginStreakWorkflow: {
+    id: string;
+    name: string;
+    execute: typeof executeAppLoginStreakWorkflow;
+};

package/dist/workflows/app-login-streak.js

@@ -0,0 +1,298 @@
+/**
+ * App Login Streak Workflow
+ *
+ * Creates a campaign to reward fans for daily app logins,
+ * with achievements for consecutive login streaks.
+ */
+import { campaignCreate, campaignList } from "../tools/campaign/handlers.js";
+import { achievementCreate, achievementList } from "../tools/achievement.js";
+import { badgeList } from "../tools/badge.js";
+import { formatOLDate, DEFAULTS } from "../prompts/fan-engagement-setup.js";
+// ============================================================================
+// Workflow Implementation
+// ============================================================================
+/**
+ * Execute the app login streak workflow
+ */
+export async function executeAppLoginStreakWorkflow(config = {}) {
+    const result = {
+        success: false,
+        errors: [],
+        summary: "",
+    };
+    // Merge with defaults
+    const cfg = {
+        coinsPerLogin: config.coinsPerLogin ?? DEFAULTS.appLoginStreak.coinsPerLogin,
+        createStreakBonus: config.createStreakBonus ?? true,
+        streakDays: config.streakDays ?? DEFAULTS.appLoginStreak.streakDays,
+        streakBonus: config.streakBonus ?? DEFAULTS.appLoginStreak.streakBonus,
+        badgeName: config.badgeName ?? "Dedicated Fan",
+        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
+        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
+    };
+    try {
+        // Step 1: Create daily login campaign (limited to 1 per day)
+        const loginCampaignResult = await createLoginCampaign(cfg);
+        if (loginCampaignResult.error) {
+            result.errors.push(loginCampaignResult.error);
+        }
+        else {
+            result.loginCampaignId = loginCampaignResult.campaignId;
+        }
+        // Step 2: Create streak achievement and bonus campaign if enabled
+        if (cfg.createStreakBonus) {
+            const badges = await getAvailableBadges();
+            const achievementResult = await createStreakAchievement(cfg, badges);
+            if (achievementResult.error) {
+                result.errors.push(achievementResult.error);
+            }
+            else {
+                result.streakAchievementId = achievementResult.achievementId;
+                // Create bonus campaign for streak achievement
+                if (achievementResult.achievementId) {
+                    const bonusCampaignResult = await createStreakBonusCampaign(achievementResult.achievementId, cfg);
+                    if (bonusCampaignResult.error) {
+                        result.errors.push(bonusCampaignResult.error);
+                    }
+                    else {
+                        result.streakBonusCampaignId = bonusCampaignResult.campaignId;
+                    }
+                }
+            }
+        }
+        // Step 3: Verify setup
+        const verification = await verifySetup(result);
+        if (verification.warnings.length > 0) {
+            result.errors.push(...verification.warnings);
+        }
+        // Determine success
+        result.success = result.loginCampaignId !== undefined && result.errors.length === 0;
+        // Build summary
+        result.summary = buildSummary(cfg, result);
+    }
+    catch (error) {
+        result.errors.push(`Workflow error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+async function createLoginCampaign(cfg) {
+    try {
+        const response = await campaignCreate({
+            type: "direct",
+            trigger: "custom_event",
+            event: "app_login",
+            translations: {
+                en: {
+                    name: "Daily App Login Reward",
+                    description: `Earn ${cfg.coinsPerLogin} coins for logging into the app daily`,
+                },
+            },
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    name: "Award coins for daily login",
+                    effects: [
+                        {
+                            effect: "give_points",
+                            pointsRule: { fixedValue: cfg.coinsPerLogin },
+                        },
+                    ],
+                },
+            ],
+            limits: {
+                // Strictly one login reward per day
+                executionsPerMember: {
+                    value: 1,
+                    interval: { type: "days", value: 1 },
+                },
+            },
+            active: true,
+        });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create login campaign: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function getAvailableBadges() {
+    try {
+        const response = await badgeList({});
+        const badgeMap = new Map();
+        for (const badge of response.badges) {
+            if (badge.name && badge.badgeTypeId) {
+                badgeMap.set(badge.name.toLowerCase(), badge.badgeTypeId);
+            }
+        }
+        return badgeMap;
+    }
+    catch {
+        return new Map();
+    }
+}
+async function createStreakAchievement(cfg, badges) {
+    try {
+        const badgeTypeId = cfg.badgeName
+            ? badges.get(cfg.badgeName.toLowerCase())
+            : undefined;
+        /**
+         * Streak achievements in Open Loyalty use:
+         * - periodGoal: 1 (one login per period)
+         * - period: { consecutive: X, value: 1 } where X is streak days
+         *
+         * This tracks consecutive periods (days) where the goal is met.
+         */
+        const achievementPayload = {
+            translations: {
+                en: {
+                    name: `${cfg.streakDays}-Day Login Streak`,
+                    description: `Log in ${cfg.streakDays} consecutive days to complete this achievement`,
+                },
+            },
+            active: true,
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    trigger: "custom_event",
+                    event: "app_login",
+                    completeRule: {
+                        periodGoal: 1,
+                        period: {
+                            consecutive: cfg.streakDays,
+                            value: 1, // 1 day period
+                        },
+                    },
+                },
+            ],
+        };
+        if (badgeTypeId) {
+            achievementPayload.badgeTypeId = badgeTypeId;
+        }
+        const response = await achievementCreate(achievementPayload);
+        return { achievementId: response.achievementId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create streak achievement: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function createStreakBonusCampaign(achievementId, cfg) {
+    try {
+        const response = await campaignCreate({
+            type: "direct",
+            trigger: "achievement",
+            translations: {
+                en: {
+                    name: `${cfg.streakDays}-Day Login Streak Bonus`,
+                    description: `Bonus ${cfg.streakBonus} coins for maintaining a ${cfg.streakDays}-day login streak`,
+                },
+            },
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    name: `Bonus for ${cfg.streakDays}-day streak`,
+                    effects: [
+                        {
+                            effect: "give_points",
+                            pointsRule: { fixedValue: cfg.streakBonus },
+                        },
+                    ],
+                    conditions: [
+                        {
+                            operator: "is_equal",
+                            attribute: "achievement.achievementId",
+                            data: { value: achievementId },
+                        },
+                    ],
+                },
+            ],
+            active: true,
+        });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create streak bonus campaign: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function verifySetup(result) {
+    const warnings = [];
+    try {
+        if (result.loginCampaignId) {
+            const campaigns = await campaignList({ active: true });
+            const found = campaigns.campaigns.some((c) => c.campaignId === result.loginCampaignId);
+            if (!found) {
+                warnings.push("Login campaign created but not found in active campaigns list");
+            }
+        }
+        if (result.streakAchievementId) {
+            const achievements = await achievementList({ active: true });
+            const found = achievements.achievements.some((a) => a.achievementId === result.streakAchievementId);
+            if (!found) {
+                warnings.push("Streak achievement created but not found in active achievements list");
+            }
+        }
+    }
+    catch (error) {
+        warnings.push(`Verification error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { warnings };
+}
+function buildSummary(cfg, result) {
+    const lines = [];
+    if (result.loginCampaignId) {
+        lines.push(`Daily login campaign created!`);
+        lines.push(`\nDaily reward: ${cfg.coinsPerLogin} coins`);
+        lines.push(`Limit: 1 reward per day (prevents multiple login scans)`);
+    }
+    if (result.streakAchievementId) {
+        lines.push(`\nStreak Achievement: ${cfg.streakDays} consecutive days`);
+        if (cfg.badgeName) {
+            lines.push(`Badge: ${cfg.badgeName}`);
+        }
+        if (result.streakBonusCampaignId) {
+            lines.push(`Streak bonus: ${cfg.streakBonus} coins`);
+        }
+    }
+    lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
+    lines.push(`\nCustom event to trigger reward:`);
+    lines.push(`  Event: app_login`);
+    lines.push(`\nExample event payload:`);
+    lines.push(`{`);
+    lines.push(`  "event": "app_login"`);
+    lines.push(`}`);
+    lines.push(`\nStreak mechanics:`);
+    lines.push(`- Fan must log in at least once each day`);
+    lines.push(`- Missing a day resets the streak counter`);
+    lines.push(`- Achievement completes when ${cfg.streakDays} consecutive days are reached`);
+    if (result.errors.length > 0) {
+        lines.push(`\nWarnings/Errors:`);
+        for (const error of result.errors) {
+            lines.push(`- ${error}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export const appLoginStreakWorkflow = {
+    id: "app-login-streak",
+    name: "App Login Streak Campaign",
+    execute: executeAppLoginStreakWorkflow,
+};

package/dist/workflows/early-arrival.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Early Arrival Workflow
+ *
+ * Creates a campaign to reward fans who arrive early to matches.
+ * Uses a custom event with minutes_before attribute for conditional rewards.
+ */
+export interface EarlyArrivalConfig {
+    /** How early (in minutes) counts as "early arrival" */
+    minutesBefore: number;
+    /** Coins awarded for early arrival */
+    coinsPerArrival: number;
+    /** Maximum early arrival bonuses per match (typically 1) */
+    limitPerMatch: number;
+    /** Season start date (ISO format) */
+    seasonStart: string;
+    /** Season end date (ISO format) */
+    seasonEnd: string;
+}
+export interface EarlyArrivalResult {
+    success: boolean;
+    campaignId?: string;
+    errors: string[];
+    summary: string;
+}
+/**
+ * Execute the early arrival workflow
+ */
+export declare function executeEarlyArrivalWorkflow(config?: Partial<EarlyArrivalConfig>): Promise<EarlyArrivalResult>;
+export declare const earlyArrivalWorkflow: {
+    id: string;
+    name: string;
+    execute: typeof executeEarlyArrivalWorkflow;
+};

package/dist/workflows/early-arrival.js

@@ -0,0 +1,148 @@
+/**
+ * Early Arrival Workflow
+ *
+ * Creates a campaign to reward fans who arrive early to matches.
+ * Uses a custom event with minutes_before attribute for conditional rewards.
+ */
+import { campaignCreate } from "../tools/campaign/handlers.js";
+import { formatOLDate, DEFAULTS } from "../prompts/fan-engagement-setup.js";
+// ============================================================================
+// Workflow Implementation
+// ============================================================================
+/**
+ * Execute the early arrival workflow
+ */
+export async function executeEarlyArrivalWorkflow(config = {}) {
+    const result = {
+        success: false,
+        errors: [],
+        summary: "",
+    };
+    // Merge with defaults
+    const cfg = {
+        minutesBefore: config.minutesBefore ?? DEFAULTS.earlyArrival.minutesBefore,
+        coinsPerArrival: config.coinsPerArrival ?? DEFAULTS.earlyArrival.coinsPerArrival,
+        limitPerMatch: config.limitPerMatch ?? DEFAULTS.earlyArrival.limitPerMatch,
+        seasonStart: config.seasonStart ?? DEFAULTS.seasonDates.start,
+        seasonEnd: config.seasonEnd ?? DEFAULTS.seasonDates.end,
+    };
+    try {
+        // Create the early arrival campaign with condition
+        const campaignResult = await createEarlyArrivalCampaign(cfg);
+        if (campaignResult.error) {
+            result.errors.push(campaignResult.error);
+        }
+        else {
+            result.campaignId = campaignResult.campaignId;
+            result.success = true;
+        }
+        // Build summary
+        result.summary = buildSummary(cfg, result);
+    }
+    catch (error) {
+        result.errors.push(`Workflow error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+async function createEarlyArrivalCampaign(cfg) {
+    try {
+        /**
+         * The early_arrival custom event expects:
+         * {
+         *   "event": "early_arrival",
+         *   "attributes": {
+         *     "minutes_before": 75  // how many minutes before kickoff they arrived
+         *   }
+         * }
+         *
+         * The campaign condition checks if minutes_before >= threshold
+         */
+        const response = await campaignCreate({
+            type: "direct",
+            trigger: "custom_event",
+            event: "early_arrival",
+            translations: {
+                en: {
+                    name: "Early Arrival Bonus",
+                    description: `Earn ${cfg.coinsPerArrival} bonus coins for arriving at least ${cfg.minutesBefore} minutes before kickoff`,
+                },
+            },
+            activity: {
+                startsAt: formatOLDate(cfg.seasonStart),
+                endsAt: formatOLDate(cfg.seasonEnd),
+            },
+            rules: [
+                {
+                    name: "Award coins for early arrival",
+                    effects: [
+                        {
+                            effect: "give_points",
+                            pointsRule: { fixedValue: cfg.coinsPerArrival },
+                        },
+                    ],
+                    conditions: [
+                        {
+                            operator: "gte",
+                            attribute: "event.minutes_before",
+                            data: { value: cfg.minutesBefore },
+                        },
+                    ],
+                },
+            ],
+            limits: {
+                executionsPerMember: {
+                    value: cfg.limitPerMatch,
+                    interval: { type: "days", value: 1 },
+                },
+            },
+            active: true,
+        });
+        return { campaignId: response.campaignId };
+    }
+    catch (error) {
+        return {
+            error: `Failed to create early arrival campaign: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function buildSummary(cfg, result) {
+    const lines = [];
+    if (result.success && result.campaignId) {
+        lines.push(`Early arrival campaign created successfully!`);
+        lines.push(`\nReward: ${cfg.coinsPerArrival} coins`);
+        lines.push(`Requirement: Arrive at least ${cfg.minutesBefore} minutes before kickoff`);
+        lines.push(`Limit: ${cfg.limitPerMatch} bonus per match day`);
+        lines.push(`\nSeason: ${cfg.seasonStart} to ${cfg.seasonEnd}`);
+        lines.push(`\nCustom event to trigger reward:`);
+        lines.push(`  Event: early_arrival`);
+        lines.push(`  Required attribute: minutes_before (number)`);
+        lines.push(`\nExample event payload:`);
+        lines.push(`{`);
+        lines.push(`  "event": "early_arrival",`);
+        lines.push(`  "attributes": {`);
+        lines.push(`    "minutes_before": 75`);
+        lines.push(`  }`);
+        lines.push(`}`);
+    }
+    else {
+        lines.push(`Early arrival campaign setup failed.`);
+    }
+    if (result.errors.length > 0) {
+        lines.push(`\nErrors:`);
+        for (const error of result.errors) {
+            lines.push(`- ${error}`);
+        }
+    }
+    return lines.join("\n");
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export const earlyArrivalWorkflow = {
+    id: "early-arrival",
+    name: "Early Arrival Campaign",
+    execute: executeEarlyArrivalWorkflow,
+};