@open-loyalty/mcp-server 1.3.7 → 1.5.3

package/dist/tools/transaction.js

@@ -1,259 +0,0 @@
-import { z } from "zod";
-import { apiGet, apiPost } from "../client/http.js";
-import { formatApiError, OpenLoyaltyError } from "../utils/errors.js";
-import { getStoreCode } from "../config.js";
-import { buildPaginationParams, normalizeDateToISO } from "../utils/pagination.js";
-// Input Schemas
-const LabelInputSchema = z.object({
-    key: z.string(),
-    value: z.string(),
-});
-const TransactionHeaderInputSchema = z.object({
-    documentNumber: z.string().describe("Unique document number (required, unique per store)."),
-    purchasedAt: z.string().describe("Purchase date/time in ISO format (required)."),
-    documentType: z.enum(["sell", "return"]).optional().describe("Document type: sell (default) or return."),
-    linkedDocumentNumber: z.string().optional().describe("Original document number (required for returns)."),
-    purchasePlace: z.string().optional().describe("Location/store where purchase was made."),
-    labels: z.array(LabelInputSchema).optional().describe("Custom key-value labels."),
-});
-const TransactionItemInputSchema = z.object({
-    sku: z.string().describe("Product SKU (required, max 255 chars)."),
-    name: z.string().describe("Product name (required, max 255 chars)."),
-    grossValue: z.number().describe("Item gross value (required)."),
-    category: z.string().describe("Product category (required, max 255 chars)."),
-    quantity: z.number().optional().describe("Item quantity (integer)."),
-    highPrecisionQuantity: z.number().optional().describe("High precision quantity (up to 3 decimals, recommended)."),
-    maker: z.string().optional().describe("Product brand/maker."),
-    labels: z.array(LabelInputSchema).optional().describe("Custom key-value labels."),
-});
-const CustomerDataInputSchema = z.object({
-    customerId: z.string().optional().describe("Member ID (UUID) for explicit assignment."),
-    email: z.string().optional().describe("Email for auto-matching to member."),
-    name: z.string().optional().describe("Customer name."),
-    phone: z.string().optional().describe("Phone for auto-matching to member."),
-    loyaltyCardNumber: z.string().optional().describe("Loyalty card for auto-matching."),
-});
-export const TransactionCreateInputSchema = {
-    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."),
-    header: TransactionHeaderInputSchema.describe("Transaction header with document info."),
-    items: z.array(TransactionItemInputSchema).describe("Array of purchased items (at least 1 required)."),
-    customerData: CustomerDataInputSchema.optional().describe("Customer data for auto-matching to member. If provided, triggers point campaigns."),
-};
-export const TransactionGetInputSchema = {
-    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."),
-    transactionId: z.string().describe("The transaction ID (UUID) to retrieve."),
-};
-export const TransactionListInputSchema = {
-    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."),
-    cursor: z.string().optional().describe("Pagination cursor from previous response. If provided, page/perPage are ignored."),
-    page: z.number().optional().describe("Page number (default: 1)."),
-    perPage: z.number().max(50).optional().describe("Items per page (default: 10, max: 50). Use 50 for aggregation queries to reduce API calls."),
-    customerId: z.string().optional().describe("Filter by member ID."),
-    documentNumber: z.string().optional().describe("Filter by document number."),
-    documentType: z.enum(["sell", "return"]).optional().describe("Filter by document type."),
-    matched: z.boolean().optional().describe("Filter by matched status."),
-    purchasedAtFrom: z.string().optional().describe("Filter transactions purchased on or after this date (ISO format: YYYY-MM-DD or YYYY-MM-DDTHH:mm:ssZ)."),
-    purchasedAtTo: z.string().optional().describe("Filter transactions purchased on or before this date (ISO format: YYYY-MM-DD or YYYY-MM-DDTHH:mm:ssZ)."),
-};
-export const TransactionAssignMemberInputSchema = {
-    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."),
-    documentNumber: z.string().describe("Document number of the transaction to assign."),
-    customerId: z.string().optional().describe("Member ID (UUID) to assign."),
-    loyaltyCardNumber: z.string().optional().describe("Loyalty card number to match member."),
-    phone: z.string().optional().describe("Phone number to match member."),
-};
-// Handler functions
-export async function transactionCreate(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    const transactionPayload = {
-        header: {
-            documentNumber: input.header.documentNumber,
-            documentType: input.header.documentType || "sell",
-            purchasedAt: input.header.purchasedAt,
-            purchasePlace: input.header.purchasePlace,
-            linkedDocumentNumber: input.header.linkedDocumentNumber,
-            labels: input.header.labels,
-        },
-        items: input.items.map((item) => ({
-            sku: item.sku,
-            name: item.name,
-            grossValue: item.grossValue,
-            category: item.category,
-            highPrecisionQuantity: item.highPrecisionQuantity || item.quantity || 1,
-            maker: item.maker,
-            labels: item.labels,
-        })),
-    };
-    if (input.customerData) {
-        transactionPayload.customerData = input.customerData;
-    }
-    try {
-        const response = await apiPost(`/${storeCode}/transaction`, { transaction: transactionPayload });
-        return {
-            transactionId: response.transactionId,
-            pointsEarned: response.pointsEarned,
-        };
-    }
-    catch (error) {
-        // Check for duplicate document number error
-        // Must check axios response data, not just error.message
-        const axiosError = error;
-        const apiErrors = axiosError.response?.data?.errors || [];
-        const allErrorMessages = apiErrors.map(e => e.message).join(" ").toLowerCase();
-        if (allErrorMessages.includes("document number") && allErrorMessages.includes("unique")) {
-            throw new OpenLoyaltyError({
-                code: "DUPLICATE_DOCUMENT",
-                message: `Transaction with document number '${input.header.documentNumber}' already exists`,
-                hint: `Each transaction must have a unique documentNumber. Use transaction_list(documentNumber: "${input.header.documentNumber}") to check if it exists, or generate a new unique document number (e.g., add timestamp suffix).`,
-                relatedTool: "ol_transaction_create",
-            });
-        }
-        throw formatApiError(error, "ol_transaction_create");
-    }
-}
-export async function transactionGet(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    try {
-        const response = await apiGet(`/${storeCode}/transaction/${input.transactionId}`);
-        const header = response.header;
-        return {
-            transactionId: response.transactionId,
-            documentNumber: (header?.documentNumber || response.documentNumber),
-            documentType: (header?.documentType || response.documentType || "sell"),
-            items: (response.items || []),
-            customerData: response.customerData,
-            matched: (response.matched ?? response.customerId != null),
-            grossValue: (response.grossValue || 0),
-            pointsEarned: response.pointsEarned,
-            purchasedAt: (header?.purchasedAt || response.purchasedAt),
-        };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_transaction_get");
-    }
-}
-export async function transactionList(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    const params = new URLSearchParams();
-    // Enforce max perPage of 50 (API limit)
-    const perPage = input.perPage ? Math.min(input.perPage, 50) : undefined;
-    // Use buildPaginationParams for cursor/page handling
-    buildPaginationParams({ cursor: input.cursor, page: input.page, perPage }, params);
-    if (input.customerId)
-        params.append("customerId", input.customerId);
-    if (input.documentNumber)
-        params.append("header:documentNumber", input.documentNumber);
-    if (input.documentType)
-        params.append("header:documentType", input.documentType);
-    if (input.matched !== undefined)
-        params.append("matched", String(input.matched));
-    if (input.purchasedAtFrom)
-        params.append("header:purchasedAt[gte]", normalizeDateToISO(input.purchasedAtFrom, "from"));
-    if (input.purchasedAtTo)
-        params.append("header:purchasedAt[lte]", normalizeDateToISO(input.purchasedAtTo, "to"));
-    const queryString = params.toString();
-    const url = `/${storeCode}/transaction${queryString ? `?${queryString}` : ""}`;
-    try {
-        const response = await apiGet(url);
-        const items = response.items || response.transactions || [];
-        const transactions = items.map((t) => {
-            const txn = t;
-            const header = txn.header;
-            const customerId = txn.customerId;
-            return {
-                transactionId: txn.transactionId,
-                documentNumber: (header?.documentNumber || txn.documentNumber),
-                grossValue: (txn.grossValue || 0),
-                matched: (txn.matched ?? customerId != null),
-                customerId,
-                pointsEarned: txn.pointsEarned,
-                purchasedAt: (header?.purchasedAt || txn.purchasedAt),
-            };
-        });
-        const total = response.total || {};
-        return {
-            transactions,
-            total: {
-                all: typeof total.all === 'number' ? total.all : undefined,
-                filtered: typeof total.filtered === 'number' ? total.filtered : undefined,
-            },
-            cursor: response.scroll,
-        };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_transaction_list");
-    }
-}
-export async function transactionAssignMember(input) {
-    const storeCode = getStoreCode(input.storeCode);
-    // At least one identifier required
-    if (!input.customerId && !input.loyaltyCardNumber && !input.phone) {
-        throw new Error("At least one member identifier required: customerId, loyaltyCardNumber, or phone.");
-    }
-    const assignPayload = {
-        transactionDocumentNumber: input.documentNumber,
-    };
-    if (input.customerId)
-        assignPayload.customerId = input.customerId;
-    if (input.loyaltyCardNumber)
-        assignPayload.customerLoyaltyCardNumber = input.loyaltyCardNumber;
-    if (input.phone)
-        assignPayload.customerPhoneNumber = input.phone;
-    try {
-        // API uses /transaction/assign with assign wrapper, not /transaction/customer/assign
-        const response = await apiPost(`/${storeCode}/transaction/assign`, { assign: assignPayload });
-        return {
-            transactionId: response.transactionId,
-            customerId: response.customerId,
-            pointsEarned: response.pointsEarned,
-        };
-    }
-    catch (error) {
-        throw formatApiError(error, "ol_transaction_assign_member");
-    }
-}
-// Tool definitions
-export const transactionToolDefinitions = [
-    {
-        name: "ol_transaction_create",
-        title: "Record Purchase",
-        description: "Record a purchase transaction. If customerData provided, auto-matches to member and triggers point campaigns. " +
-            "For returns, set documentType='return' and provide linkedDocumentNumber referencing original sale. " +
-            "Returns transactionId and pointsEarned if campaigns triggered.",
-        readOnly: false,
-        inputSchema: TransactionCreateInputSchema,
-        handler: transactionCreate,
-    },
-    {
-        name: "ol_transaction_get",
-        title: "Get Transaction Details",
-        description: "Get transaction details including items, customerData, matched status, and pointsEarned.",
-        readOnly: true,
-        inputSchema: TransactionGetInputSchema,
-        handler: transactionGet,
-    },
-    {
-        name: "ol_transaction_list",
-        title: "Search Transactions",
-        description: "List transactions with optional filters. Filter by customerId, documentNumber, documentType, matched status, or date range (purchasedAtFrom/purchasedAtTo). " +
-            "Use ISO date format for date filters (e.g., '2025-07-01' or '2025-07-01T00:00:00Z'). " +
-            "Supports cursor pagination: provide 'cursor' from previous response to get next page. " +
-            "Returns customerId for matched transactions - use this for aggregation queries like 'top spenders'. " +
-            "IMPORTANT FOR AGGREGATION QUERIES: Always use cursor pagination and iterate through ALL pages, even for large datasets (1000+ transactions). " +
-            "Do NOT try to optimize or find shortcuts - the cursor approach is the correct and only way to get accurate results. " +
-            "Start with cursor='' (empty string), then use returned cursor for subsequent requests until no more data. " +
-            "Use perPage=50 to minimize API calls. Aggregate by customerId in your code, then use member_get for names.",
-        readOnly: true,
-        inputSchema: TransactionListInputSchema,
-        handler: transactionList,
-    },
-    {
-        name: "ol_transaction_assign_member",
-        title: "Link Transaction to Member",
-        description: "Assign unmatched transaction to member by ID, card number, or phone. Triggers point campaigns. " +
-            "Use this to link a transaction that wasn't matched at creation time. Returns transactionId, customerId, and pointsEarned.",
-        readOnly: false,
-        inputSchema: TransactionAssignMemberInputSchema,
-        handler: transactionAssignMember,
-    },
-];

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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,298 +0,0 @@
-/**
- * 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

@@ -1,33 +0,0 @@
-/**
- * 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;
-};