@open-loyalty/mcp-server 1.0.0

package/dist/tools/transaction.test.js

@@ -0,0 +1,235 @@
+// src/tools/transaction.test.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { setupMockAxios, teardownMockAxios, getMockAxios } from '../../tests/mocks/http.mock.js';
+import { transactionFixtures } from '../../tests/fixtures/transaction.fixtures.js';
+import { transactionCreate, transactionGet, transactionList, transactionAssignMember, } from './transaction.js';
+describe('Transaction Operations', () => {
+    beforeEach(() => {
+        setupMockAxios();
+    });
+    afterEach(() => {
+        teardownMockAxios();
+    });
+    describe('transactionCreate', () => {
+        it('should create transaction with transaction wrapper', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction').reply(200, transactionFixtures.createResponse);
+            const result = await transactionCreate({
+                header: {
+                    documentNumber: 'DOC-001',
+                    purchasedAt: '2026-01-15T10:00:00Z',
+                },
+                items: [
+                    {
+                        sku: 'PROD-001',
+                        name: 'Test Product',
+                        grossValue: 100,
+                        category: 'Electronics',
+                    },
+                ],
+            });
+            expect(result.transactionId).toBe('txn-uuid-123');
+            // Verify request body format with transaction wrapper
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transaction).toBeDefined();
+            expect(requestData.transaction.header.documentNumber).toBe('DOC-001');
+            expect(requestData.transaction.header.documentType).toBe('sell');
+            expect(requestData.transaction.items).toHaveLength(1);
+            expect(requestData.transaction.items[0].sku).toBe('PROD-001');
+        });
+        it('should include customerData for member matching', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction').reply(200, {
+                transactionId: 'txn-uuid',
+                pointsEarned: 100,
+            });
+            const result = await transactionCreate({
+                header: {
+                    documentNumber: 'DOC-002',
+                    purchasedAt: '2026-01-15T10:00:00Z',
+                },
+                items: [
+                    {
+                        sku: 'PROD-001',
+                        name: 'Product',
+                        grossValue: 100,
+                        category: 'Category',
+                    },
+                ],
+                customerData: {
+                    email: 'customer@example.com',
+                },
+            });
+            expect(result.pointsEarned).toBe(100);
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transaction.customerData.email).toBe('customer@example.com');
+        });
+        it('should handle return transactions', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction').reply(200, transactionFixtures.createResponse);
+            await transactionCreate({
+                header: {
+                    documentNumber: 'RETURN-001',
+                    purchasedAt: '2026-01-15T10:00:00Z',
+                    documentType: 'return',
+                    linkedDocumentNumber: 'DOC-001',
+                },
+                items: [
+                    {
+                        sku: 'PROD-001',
+                        name: 'Product',
+                        grossValue: -50,
+                        category: 'Category',
+                    },
+                ],
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transaction.header.documentType).toBe('return');
+            expect(requestData.transaction.header.linkedDocumentNumber).toBe('DOC-001');
+        });
+        it('should use highPrecisionQuantity', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction').reply(200, transactionFixtures.createResponse);
+            await transactionCreate({
+                header: {
+                    documentNumber: 'DOC-003',
+                    purchasedAt: '2026-01-15T10:00:00Z',
+                },
+                items: [
+                    {
+                        sku: 'PROD-001',
+                        name: 'Product',
+                        grossValue: 100,
+                        category: 'Category',
+                        highPrecisionQuantity: 1.5,
+                    },
+                ],
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transaction.items[0].highPrecisionQuantity).toBe(1.5);
+        });
+        it('should use custom storeCode', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/custom-store/transaction').reply(200, transactionFixtures.createResponse);
+            await transactionCreate({
+                storeCode: 'custom-store',
+                header: {
+                    documentNumber: 'DOC-001',
+                    purchasedAt: '2026-01-15T10:00:00Z',
+                },
+                items: [
+                    {
+                        sku: 'PROD-001',
+                        name: 'Product',
+                        grossValue: 100,
+                        category: 'Category',
+                    },
+                ],
+            });
+            expect(mockAxios.history.post[0].url).toBe('/custom-store/transaction');
+        });
+    });
+    describe('transactionGet', () => {
+        it('should get transaction details', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/transaction/txn-uuid').reply(200, transactionFixtures.getResponse);
+            const result = await transactionGet({ transactionId: 'txn-uuid' });
+            expect(result.transactionId).toBe('txn-uuid-123');
+            expect(result.documentNumber).toBe('DOC-001');
+            expect(result.documentType).toBe('sell');
+            expect(result.matched).toBe(true);
+            expect(result.grossValue).toBe(150);
+            expect(result.pointsEarned).toBe(150);
+        });
+        it('should extract documentNumber from header', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/transaction/txn-uuid').reply(200, {
+                transactionId: 'txn-uuid',
+                header: {
+                    documentNumber: 'DOC-FROM-HEADER',
+                    documentType: 'sell',
+                    purchasedAt: '2026-01-15T10:00:00Z',
+                },
+                items: [],
+                matched: true,
+                grossValue: 100,
+            });
+            const result = await transactionGet({ transactionId: 'txn-uuid' });
+            expect(result.documentNumber).toBe('DOC-FROM-HEADER');
+        });
+    });
+    describe('transactionList', () => {
+        it('should list transactions from items array', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet('/default/transaction').reply(200, transactionFixtures.listResponse);
+            const result = await transactionList({});
+            expect(result.transactions).toHaveLength(2);
+            expect(result.transactions[0].transactionId).toBe('txn-uuid-1');
+            expect(result.transactions[0].documentNumber).toBe('DOC-001');
+            expect(result.transactions[0].matched).toBe(true);
+        });
+        it('should include pagination params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/transaction/).reply(200, transactionFixtures.listResponse);
+            await transactionList({ page: 2, perPage: 25 });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('_page=2');
+            expect(url).toContain('_itemsOnPage=25');
+        });
+        it('should include filter params', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onGet(/\/default\/transaction/).reply(200, transactionFixtures.listResponse);
+            await transactionList({
+                customerId: 'member-uuid',
+                documentNumber: 'DOC-001',
+                documentType: 'sell',
+                matched: true,
+            });
+            const url = mockAxios.history.get[0].url;
+            expect(url).toContain('customerId=member-uuid');
+            expect(url).toContain('header%3AdocumentNumber=DOC-001');
+            expect(url).toContain('header%3AdocumentType=sell');
+            expect(url).toContain('matched=true');
+        });
+    });
+    describe('transactionAssignMember', () => {
+        it('should assign transaction to member by customerId', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction/customer/assign').reply(200, transactionFixtures.assignResponse);
+            const result = await transactionAssignMember({
+                documentNumber: 'DOC-001',
+                customerId: 'member-uuid',
+            });
+            expect(result.transactionId).toBe('txn-uuid-123');
+            expect(result.customerId).toBe('member-uuid');
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.transactionDocumentNumber).toBe('DOC-001');
+            expect(requestData.customerId).toBe('member-uuid');
+        });
+        it('should assign by loyalty card number', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction/customer/assign').reply(200, transactionFixtures.assignResponse);
+            await transactionAssignMember({
+                documentNumber: 'DOC-001',
+                loyaltyCardNumber: 'CARD123456',
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.customerLoyaltyCardNumber).toBe('CARD123456');
+        });
+        it('should assign by phone number', async () => {
+            const mockAxios = getMockAxios();
+            mockAxios.onPost('/default/transaction/customer/assign').reply(200, transactionFixtures.assignResponse);
+            await transactionAssignMember({
+                documentNumber: 'DOC-001',
+                phone: '+1234567890',
+            });
+            const requestData = JSON.parse(mockAxios.history.post[0].data);
+            expect(requestData.customerPhoneNumber).toBe('+1234567890');
+        });
+        it('should throw error when no identifier provided', async () => {
+            await expect(transactionAssignMember({
+                documentNumber: 'DOC-001',
+            })).rejects.toThrow('At least one member identifier required');
+        });
+    });
+});

package/dist/tools/wallet-type.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { WalletType } from "../types/schemas/wallet-type.js";
+export declare const WalletTypeListInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+};
+export declare const WalletTypeGetInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    walletTypeId: z.ZodString;
+};
+export declare function walletTypeList(input: {
+    storeCode?: string;
+}): Promise<WalletType[]>;
+export declare function walletTypeGet(input: {
+    storeCode?: string;
+    walletTypeId: string;
+}): Promise<WalletType>;
+export declare const walletTypeToolDefinitions: readonly [{
+    readonly name: "openloyalty_wallet_type_list";
+    readonly description: "List all available wallet types (point currencies). Use this to find walletCode values for tier conditions. Returns walletTypeId, code, and name for each wallet type.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof walletTypeList;
+}, {
+    readonly name: "openloyalty_wallet_type_get";
+    readonly description: "Get details for a specific wallet type by ID. Returns the full wallet type configuration including currency names.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        walletTypeId: z.ZodString;
+    };
+    readonly handler: typeof walletTypeGet;
+}];

package/dist/tools/wallet-type.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { apiGet } from "../client/http.js";
+import { WalletTypeSchema, WalletTypeListResponseSchema, } from "../types/schemas/wallet-type.js";
+import { formatApiError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+export const WalletTypeListInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+};
+export const WalletTypeGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    walletTypeId: z.string().describe("The wallet type ID to retrieve."),
+};
+export async function walletTypeList(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/walletType`);
+        const validated = WalletTypeListResponseSchema.parse(response);
+        return validated.items.map((wt) => ({
+            walletTypeId: wt.walletTypeId,
+            code: wt.code,
+            name: wt.name,
+            unitSingularName: wt.unitSingularName,
+            unitPluralName: wt.unitPluralName,
+            active: wt.active,
+            isDefault: wt.isDefault,
+        }));
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_wallet_type_list");
+    }
+}
+export async function walletTypeGet(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/walletType/${input.walletTypeId}`);
+        const validated = WalletTypeSchema.parse(response);
+        return validated;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_wallet_type_get");
+    }
+}
+export const walletTypeToolDefinitions = [
+    {
+        name: "openloyalty_wallet_type_list",
+        description: "List all available wallet types (point currencies). Use this to find walletCode values for tier conditions. Returns walletTypeId, code, and name for each wallet type.",
+        inputSchema: WalletTypeListInputSchema,
+        handler: walletTypeList,
+    },
+    {
+        name: "openloyalty_wallet_type_get",
+        description: "Get details for a specific wallet type by ID. Returns the full wallet type configuration including currency names.",
+        inputSchema: WalletTypeGetInputSchema,
+        handler: walletTypeGet,
+    },
+];

package/dist/tools/webhook.d.ts

@@ -0,0 +1,179 @@
+import { z } from "zod";
+export interface WebhookHeader {
+    headerName: string;
+    headerValue: string;
+}
+export interface WebhookSubscription {
+    webhookSubscriptionId: string;
+    eventName: string;
+    url: string;
+    headers?: WebhookHeader[];
+    createdAt?: string;
+}
+export interface WebhookSubscriptionListResponse {
+    items: WebhookSubscription[];
+    total?: {
+        all?: number | string;
+        filtered?: number | string;
+        estimated?: boolean;
+    };
+}
+export interface WebhookEventTypesResponse {
+    items: string[];
+}
+export declare const WebhookListInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    eventName: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+};
+export declare const WebhookCreateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    eventName: z.ZodString;
+    url: z.ZodString;
+    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        headerName: z.ZodString;
+        headerValue: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        headerName: string;
+        headerValue: string;
+    }, {
+        headerName: string;
+        headerValue: string;
+    }>, "many">>;
+};
+export declare const WebhookGetInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    webhookSubscriptionId: z.ZodString;
+};
+export declare const WebhookUpdateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    webhookSubscriptionId: z.ZodString;
+    eventName: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        headerName: z.ZodString;
+        headerValue: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        headerName: string;
+        headerValue: string;
+    }, {
+        headerName: string;
+        headerValue: string;
+    }>, "many">>;
+};
+export declare const WebhookDeleteInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    webhookSubscriptionId: z.ZodString;
+};
+export declare const WebhookEventsInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+};
+export declare function webhookList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    eventName?: string;
+    url?: string;
+}): Promise<WebhookSubscriptionListResponse>;
+export declare function webhookCreate(input: {
+    storeCode?: string;
+    eventName: string;
+    url: string;
+    headers?: WebhookHeader[];
+}): Promise<{
+    webhookSubscriptionId: string;
+}>;
+export declare function webhookGet(input: {
+    storeCode?: string;
+    webhookSubscriptionId: string;
+}): Promise<WebhookSubscription>;
+export declare function webhookUpdate(input: {
+    storeCode?: string;
+    webhookSubscriptionId: string;
+    eventName?: string;
+    url?: string;
+    headers?: WebhookHeader[];
+}): Promise<void>;
+export declare function webhookDelete(input: {
+    storeCode?: string;
+    webhookSubscriptionId: string;
+}): Promise<void>;
+export declare function webhookEvents(input: {
+    storeCode?: string;
+}): Promise<WebhookEventTypesResponse>;
+export declare const webhookToolDefinitions: readonly [{
+    readonly name: "openloyalty_webhook_list";
+    readonly description: "List webhook subscriptions with optional filtering. Returns paginated list of subscriptions with webhookSubscriptionId, eventName, url, and createdAt.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        eventName: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof webhookList;
+}, {
+    readonly name: "openloyalty_webhook_create";
+    readonly description: "Create a new webhook subscription to receive event notifications. Returns webhookSubscriptionId on success. Use webhook_events to discover available event types before creating subscriptions.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        eventName: z.ZodString;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            headerName: z.ZodString;
+            headerValue: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            headerName: string;
+            headerValue: string;
+        }, {
+            headerName: string;
+            headerValue: string;
+        }>, "many">>;
+    };
+    readonly handler: typeof webhookCreate;
+}, {
+    readonly name: "openloyalty_webhook_get";
+    readonly description: "Get full webhook subscription details including headers configuration.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        webhookSubscriptionId: z.ZodString;
+    };
+    readonly handler: typeof webhookGet;
+}, {
+    readonly name: "openloyalty_webhook_update";
+    readonly description: "Update a webhook subscription. Can update eventName, url, and headers. Returns void on success (204 No Content).";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        webhookSubscriptionId: z.ZodString;
+        eventName: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            headerName: z.ZodString;
+            headerValue: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            headerName: string;
+            headerValue: string;
+        }, {
+            headerName: string;
+            headerValue: string;
+        }>, "many">>;
+    };
+    readonly handler: typeof webhookUpdate;
+}, {
+    readonly name: "openloyalty_webhook_delete";
+    readonly description: "Delete a webhook subscription. Returns void on success (204 No Content). The subscription will stop receiving events immediately.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        webhookSubscriptionId: z.ZodString;
+    };
+    readonly handler: typeof webhookDelete;
+}, {
+    readonly name: "openloyalty_webhook_events";
+    readonly description: "Get available webhook event types. Returns list of event names that can be used when creating webhook subscriptions. Use this to discover available events before creating subscriptions.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof webhookEvents;
+}];

package/dist/tools/webhook.js

@@ -0,0 +1,171 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiDelete } from "../client/http.js";
+import { formatApiError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+// Input Schemas
+export const WebhookListInputSchema = {
+    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: 25)."),
+    eventName: z.string().optional().describe("Filter by event name."),
+    url: z.string().optional().describe("Filter by URL."),
+};
+export const WebhookCreateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    eventName: z.string().describe("Event name to subscribe to. Use webhook_events to discover available events."),
+    url: z.string().describe("URL to receive webhook events."),
+    headers: z.array(z.object({
+        headerName: z.string().describe("Header name."),
+        headerValue: z.string().describe("Header value."),
+    })).optional().describe("Custom headers to include in webhook requests."),
+};
+export const WebhookGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    webhookSubscriptionId: z.string().describe("The webhook subscription ID (UUID) to retrieve."),
+};
+export const WebhookUpdateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    webhookSubscriptionId: z.string().describe("The webhook subscription ID (UUID) to update."),
+    eventName: z.string().optional().describe("Event name to subscribe to."),
+    url: z.string().optional().describe("URL to receive webhook events."),
+    headers: z.array(z.object({
+        headerName: z.string().describe("Header name."),
+        headerValue: z.string().describe("Header value."),
+    })).optional().describe("Custom headers to include in webhook requests."),
+};
+export const WebhookDeleteInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    webhookSubscriptionId: z.string().describe("The webhook subscription ID (UUID) to delete."),
+};
+export const WebhookEventsInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+};
+// Handler functions
+export async function webhookList(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.eventName)
+        params.append("eventName", input.eventName);
+    if (input.url)
+        params.append("url", input.url);
+    const queryString = params.toString();
+    const url = `/${storeCode}/webhook/subscription${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_webhook_list");
+    }
+}
+export async function webhookCreate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {
+        eventName: input.eventName,
+        url: input.url,
+    };
+    if (input.headers) {
+        payload.headers = input.headers;
+    }
+    try {
+        const response = await apiPost(`/${storeCode}/webhook/subscription`, { webhookSubscription: payload });
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_webhook_create");
+    }
+}
+export async function webhookGet(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/webhook/subscription/${input.webhookSubscriptionId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_webhook_get");
+    }
+}
+export async function webhookUpdate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {};
+    if (input.eventName)
+        payload.eventName = input.eventName;
+    if (input.url)
+        payload.url = input.url;
+    if (input.headers)
+        payload.headers = input.headers;
+    try {
+        await apiPut(`/${storeCode}/webhook/subscription/${input.webhookSubscriptionId}`, { webhookSubscription: payload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_webhook_update");
+    }
+}
+export async function webhookDelete(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        await apiDelete(`/${storeCode}/webhook/subscription/${input.webhookSubscriptionId}`);
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_webhook_delete");
+    }
+}
+export async function webhookEvents(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/webhook/event`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_webhook_events");
+    }
+}
+// Tool definitions
+export const webhookToolDefinitions = [
+    {
+        name: "openloyalty_webhook_list",
+        description: "List webhook subscriptions with optional filtering. Returns paginated list of subscriptions with webhookSubscriptionId, eventName, url, and createdAt.",
+        inputSchema: WebhookListInputSchema,
+        handler: webhookList,
+    },
+    {
+        name: "openloyalty_webhook_create",
+        description: "Create a new webhook subscription to receive event notifications. Returns webhookSubscriptionId on success. Use webhook_events to discover available event types before creating subscriptions.",
+        inputSchema: WebhookCreateInputSchema,
+        handler: webhookCreate,
+    },
+    {
+        name: "openloyalty_webhook_get",
+        description: "Get full webhook subscription details including headers configuration.",
+        inputSchema: WebhookGetInputSchema,
+        handler: webhookGet,
+    },
+    {
+        name: "openloyalty_webhook_update",
+        description: "Update a webhook subscription. Can update eventName, url, and headers. Returns void on success (204 No Content).",
+        inputSchema: WebhookUpdateInputSchema,
+        handler: webhookUpdate,
+    },
+    {
+        name: "openloyalty_webhook_delete",
+        description: "Delete a webhook subscription. Returns void on success (204 No Content). The subscription will stop receiving events immediately.",
+        inputSchema: WebhookDeleteInputSchema,
+        handler: webhookDelete,
+    },
+    {
+        name: "openloyalty_webhook_events",
+        description: "Get available webhook event types. Returns list of event names that can be used when creating webhook subscriptions. Use this to discover available events before creating subscriptions.",
+        inputSchema: WebhookEventsInputSchema,
+        handler: webhookEvents,
+    },
+];