@open-loyalty/mcp-server 1.0.0

package/dist/tools/achievement.js

@@ -0,0 +1,311 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiPatch } from "../client/http.js";
+import { formatApiError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+// Input Schemas
+export const AchievementListInputSchema = {
+    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."),
+    name: z.string().optional().describe("Filter by achievement name."),
+};
+// Rule input schema
+const AchievementRuleInputSchema = z.object({
+    achievementRuleId: z.string().optional().describe("Rule ID (for updates)."),
+    translations: z.record(z.string(), z.object({
+        name: z.string(),
+        description: z.string().optional(),
+    })).optional().describe("Rule name and description translations."),
+    trigger: z.string().optional().describe("Event type: transaction, custom_event, points_transfer, etc."),
+    type: z.string().optional().describe("Rule type."),
+    event: z.string().optional().describe("Custom event code for custom_event trigger."),
+    completeRule: z.object({
+        periodGoal: z.union([z.number(), z.string()]).describe("Goal value to reach."),
+        period: z.object({
+            consecutive: z.number().optional(),
+            value: z.number().optional(),
+        }).optional(),
+        uniqueAttribute: z.string().optional(),
+    }).describe("Completion goal configuration."),
+    aggregation: z.object({
+        rule: z.string().optional(),
+    }).optional().describe("Value aggregation."),
+    conditions: z.array(z.record(z.unknown())).optional().describe("Conditions that must be met."),
+    limit: z.object({
+        value: z.number().optional(),
+        interval: z.object({
+            type: z.string(),
+            value: z.number().optional(),
+        }).optional(),
+    }).optional().describe("Per-rule limit."),
+    uniqueReferee: z.boolean().optional().describe("Whether referee must be unique."),
+});
+export const AchievementCreateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    translations: z.record(z.string(), z.object({
+        name: z.string(),
+        description: z.string().optional(),
+    })).describe("Achievement name and description. At least 'en' key required."),
+    active: z.boolean().optional().describe("Whether achievement is active (default: false)."),
+    activity: z.object({
+        startsAt: z.string().optional().describe("ISO datetime when achievement becomes active."),
+        endsAt: z.string().optional().describe("ISO datetime when achievement ends."),
+        operator: z.string().optional().describe("Activity condition operator."),
+    }).optional().describe("Time period configuration."),
+    limit: z.object({
+        value: z.number().optional().describe("Maximum completions."),
+        interval: z.object({
+            type: z.string(),
+            value: z.number().optional(),
+        }).optional(),
+    }).optional().describe("Overall limit configuration."),
+    rules: z.array(AchievementRuleInputSchema).describe("Achievement rules defining completion criteria."),
+    badgeTypeId: z.string().optional().describe("Badge type ID to award upon completion."),
+};
+export const AchievementGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    achievementId: z.string().describe("The achievement ID (UUID) to retrieve."),
+};
+export const AchievementUpdateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    achievementId: z.string().describe("The achievement ID (UUID) to update."),
+    translations: z.record(z.string(), z.object({
+        name: z.string(),
+        description: z.string().optional(),
+    })).describe("Achievement name and description."),
+    active: z.boolean().optional().describe("Whether achievement is active."),
+    activity: z.object({
+        startsAt: z.string().optional(),
+        endsAt: z.string().optional(),
+        operator: z.string().optional(),
+    }).optional().describe("Time period configuration."),
+    limit: z.object({
+        value: z.number().optional(),
+        interval: z.object({
+            type: z.string(),
+            value: z.number().optional(),
+        }).optional(),
+    }).optional().describe("Limit configuration."),
+    rules: z.array(AchievementRuleInputSchema).describe("Achievement rules."),
+    badgeTypeId: z.string().optional().describe("Badge type ID to award."),
+};
+export const AchievementPatchInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    achievementId: z.string().describe("The achievement ID (UUID) to patch."),
+    active: z.boolean().optional().describe("Whether achievement is active."),
+    translations: z.record(z.string(), z.object({
+        name: z.string().optional(),
+        description: z.string().optional(),
+    })).optional().describe("Partial translation updates."),
+};
+export const AchievementGetMemberProgressInputSchema = {
+    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)."),
+    achievementId: z.string().describe("The achievement ID (UUID)."),
+};
+export const AchievementListMemberAchievementsInputSchema = {
+    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)."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    name: z.string().optional().describe("Filter by achievement name."),
+    achievementId: z.string().optional().describe("Filter by specific achievement ID."),
+};
+// Handler functions
+export async function achievementList(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.name)
+        params.append("name", input.name);
+    const queryString = params.toString();
+    const url = `/${storeCode}/achievement${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const achievements = (response.items || []).map((item) => ({
+            achievementId: item.achievementId,
+            name: item.name,
+            active: item.active,
+            createdAt: item.createdAt,
+            badgeTypeId: item.badgeTypeId,
+        }));
+        const total = response.total || {};
+        return {
+            achievements,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_list");
+    }
+}
+export async function achievementCreate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const achievementPayload = {
+        translations: input.translations,
+        rules: input.rules,
+    };
+    if (input.active !== undefined)
+        achievementPayload.active = input.active;
+    if (input.activity)
+        achievementPayload.activity = input.activity;
+    if (input.limit)
+        achievementPayload.limit = input.limit;
+    if (input.badgeTypeId)
+        achievementPayload.badgeTypeId = input.badgeTypeId;
+    try {
+        // CRITICAL: Wrap body as { achievement: {...} }
+        const response = await apiPost(`/${storeCode}/achievement`, { achievement: achievementPayload });
+        return { achievementId: response.achievementId };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_create");
+    }
+}
+export async function achievementGet(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/achievement/${input.achievementId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_get");
+    }
+}
+export async function achievementUpdate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const achievementPayload = {
+        translations: input.translations,
+        rules: input.rules,
+    };
+    if (input.active !== undefined)
+        achievementPayload.active = input.active;
+    if (input.activity)
+        achievementPayload.activity = input.activity;
+    if (input.limit)
+        achievementPayload.limit = input.limit;
+    if (input.badgeTypeId !== undefined)
+        achievementPayload.badgeTypeId = input.badgeTypeId;
+    try {
+        // CRITICAL: Wrap body as { achievement: {...} }
+        await apiPut(`/${storeCode}/achievement/${input.achievementId}`, { achievement: achievementPayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_update");
+    }
+}
+export async function achievementPatch(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const achievementPayload = {};
+    if (input.active !== undefined)
+        achievementPayload.active = input.active;
+    if (input.translations)
+        achievementPayload.translations = input.translations;
+    try {
+        // CRITICAL: Wrap body as { achievement: {...} }
+        await apiPatch(`/${storeCode}/achievement/${input.achievementId}`, { achievement: achievementPayload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_patch");
+    }
+}
+export async function achievementGetMemberProgress(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/member/${input.memberId}/achievement/${input.achievementId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_get_member_progress");
+    }
+}
+export async function achievementListMemberAchievements(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.name)
+        params.append("name", input.name);
+    if (input.achievementId)
+        params.append("achievementId", input.achievementId);
+    const queryString = params.toString();
+    const url = `/${storeCode}/member/${input.memberId}/achievement${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const achievements = response.items || [];
+        const total = response.total || {};
+        return {
+            achievements,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_achievement_list_member_achievements");
+    }
+}
+// Tool definitions
+export const achievementToolDefinitions = [
+    {
+        name: "openloyalty_achievement_list",
+        description: "List achievements. Achievements gamify member behavior by setting goals (e.g., 'Make 5 purchases this month'). Returns achievementId, name, active status, and associated badge. Use achievement_get for full rules and configuration.",
+        inputSchema: AchievementListInputSchema,
+        handler: achievementList,
+    },
+    {
+        name: "openloyalty_achievement_create",
+        description: "Create achievement with rules that track member progress. Triggers: transaction (purchases), custom_event (custom actions), points_transfer, referral, etc. CompleteRule sets the goal: periodGoal (target value) with optional period (consecutive periods). Example - '5 purchases/month': rules: [{ trigger: 'transaction', completeRule: { periodGoal: 5, period: { value: 1, consecutive: 1 } } }]",
+        inputSchema: AchievementCreateInputSchema,
+        handler: achievementCreate,
+    },
+    {
+        name: "openloyalty_achievement_get",
+        description: "Get achievement details including all rules, conditions, activity period, limits, and completions count.",
+        inputSchema: AchievementGetInputSchema,
+        handler: achievementGet,
+    },
+    {
+        name: "openloyalty_achievement_update",
+        description: "Update achievement configuration. Requires full achievement object (translations, rules). Use achievement_get first to retrieve current configuration.",
+        inputSchema: AchievementUpdateInputSchema,
+        handler: achievementUpdate,
+    },
+    {
+        name: "openloyalty_achievement_patch",
+        description: "Partial update of achievement. Use for simple changes like activating/deactivating or updating translations without providing full rules.",
+        inputSchema: AchievementPatchInputSchema,
+        handler: achievementPatch,
+    },
+    {
+        name: "openloyalty_achievement_get_member_progress",
+        description: "Get member's progress on a specific achievement. Returns completedCount, and for each rule: periodGoal, currentPeriodValue, and consecutive period tracking.",
+        inputSchema: AchievementGetMemberProgressInputSchema,
+        handler: achievementGetMemberProgress,
+    },
+    {
+        name: "openloyalty_achievement_list_member_achievements",
+        description: "List all achievements with member's progress. Returns each achievement's status, completion count, and per-rule progress. Use for displaying gamification dashboard.",
+        inputSchema: AchievementListMemberAchievementsInputSchema,
+        handler: achievementListMemberAchievements,
+    },
+];

package/dist/tools/admin.d.ts

@@ -0,0 +1,153 @@
+import { z } from "zod";
+import { AdminUser, AdminUserListItem, AdminPermission } from "../types/schemas/admin.js";
+export declare const AdminListInputSchema: {
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    email: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+};
+export declare const AdminCreateInputSchema: {
+    email: z.ZodString;
+    password: z.ZodString;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    external: z.ZodOptional<z.ZodBoolean>;
+    notificationsEnabled: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const AdminGetInputSchema: {
+    adminId: z.ZodString;
+};
+export declare const AdminUpdateInputSchema: {
+    adminId: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    external: z.ZodOptional<z.ZodBoolean>;
+    notificationsEnabled: z.ZodOptional<z.ZodBoolean>;
+    password: z.ZodOptional<z.ZodString>;
+};
+export declare const AdminChangePasswordInputSchema: {
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+};
+export declare function adminList(input: {
+    page?: number;
+    perPage?: number;
+    email?: string;
+    isActive?: boolean;
+    firstName?: string;
+    lastName?: string;
+    role?: string;
+}): Promise<{
+    items: AdminUserListItem[];
+    total?: number;
+}>;
+export declare function adminCreate(input: {
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    roles?: (string | number)[];
+    isActive?: boolean;
+    external?: boolean;
+    notificationsEnabled?: boolean;
+}): Promise<{
+    adminId: string;
+}>;
+export declare function adminGet(input: {
+    adminId: string;
+}): Promise<AdminUser>;
+export declare function adminUpdate(input: {
+    adminId: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    roles?: (string | number)[];
+    isActive?: boolean;
+    external?: boolean;
+    notificationsEnabled?: boolean;
+    password?: string;
+}): Promise<{
+    adminId: string;
+}>;
+export declare function adminChangePassword(input: {
+    currentPassword: string;
+    newPassword: string;
+}): Promise<void>;
+export declare function adminGetPermissions(): Promise<AdminPermission>;
+export declare const adminToolDefinitions: readonly [{
+    readonly name: "openloyalty_admin_list";
+    readonly description: "List admin users with optional filtering. Returns paginated list of admin users with id, email, firstName, lastName, isActive, createdAt.";
+    readonly inputSchema: {
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        email: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof adminList;
+}, {
+    readonly name: "openloyalty_admin_create";
+    readonly description: "Create a new admin user. Requires email and password. Optionally assign roles, set active status, and configure notifications. Returns adminId.";
+    readonly inputSchema: {
+        email: z.ZodString;
+        password: z.ZodString;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        phone: z.ZodOptional<z.ZodString>;
+        roles: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        external: z.ZodOptional<z.ZodBoolean>;
+        notificationsEnabled: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof adminCreate;
+}, {
+    readonly name: "openloyalty_admin_get";
+    readonly description: "Get full admin user details by ID. Returns profile including email, name, roles, settings, active status, and creation date.";
+    readonly inputSchema: {
+        adminId: z.ZodString;
+    };
+    readonly handler: typeof adminGet;
+}, {
+    readonly name: "openloyalty_admin_update";
+    readonly description: "Update admin user profile. Can update email, name, phone, roles, active status, and password. Returns adminId on success.";
+    readonly inputSchema: {
+        adminId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        firstName: z.ZodOptional<z.ZodString>;
+        lastName: z.ZodOptional<z.ZodString>;
+        phone: z.ZodOptional<z.ZodString>;
+        roles: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        external: z.ZodOptional<z.ZodBoolean>;
+        notificationsEnabled: z.ZodOptional<z.ZodBoolean>;
+        password: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof adminUpdate;
+}, {
+    readonly name: "openloyalty_admin_change_password";
+    readonly description: "Change the currently logged-in admin's password. Requires current password for verification. Returns void on success.";
+    readonly inputSchema: {
+        currentPassword: z.ZodString;
+        newPassword: z.ZodString;
+    };
+    readonly handler: typeof adminChangePassword;
+}, {
+    readonly name: "openloyalty_admin_get_permissions";
+    readonly description: "Get the current admin user's permissions. Returns superAdmin flag, list of roles, and list of permission strings. Use to check what actions are available.";
+    readonly inputSchema: {};
+    readonly handler: typeof adminGetPermissions;
+}];

package/dist/tools/admin.js

@@ -0,0 +1,193 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut } from "../client/http.js";
+import { formatApiError } from "../utils/errors.js";
+// Input Schemas
+export const AdminListInputSchema = {
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 25)."),
+    email: z.string().optional().describe("Filter by email address."),
+    isActive: z.boolean().optional().describe("Filter by active status."),
+    firstName: z.string().optional().describe("Filter by first name."),
+    lastName: z.string().optional().describe("Filter by last name."),
+    role: z.string().optional().describe("Filter by role."),
+};
+export const AdminCreateInputSchema = {
+    email: z.string().describe("Admin email address (required)."),
+    password: z.string().describe("Admin password (required)."),
+    firstName: z.string().optional().describe("Admin first name."),
+    lastName: z.string().optional().describe("Admin last name."),
+    phone: z.string().optional().describe("Admin phone number."),
+    roles: z.array(z.union([z.string(), z.number()])).optional().describe("Role IDs to assign."),
+    isActive: z.boolean().optional().describe("Whether account is active (default: true)."),
+    external: z.boolean().optional().describe("Whether admin is external."),
+    notificationsEnabled: z.boolean().optional().describe("Whether notifications are enabled."),
+};
+export const AdminGetInputSchema = {
+    adminId: z.string().describe("The admin ID (UUID) to retrieve."),
+};
+export const AdminUpdateInputSchema = {
+    adminId: z.string().describe("The admin ID (UUID) to update."),
+    email: z.string().optional().describe("Admin email address."),
+    firstName: z.string().optional().describe("Admin first name."),
+    lastName: z.string().optional().describe("Admin last name."),
+    phone: z.string().optional().describe("Admin phone number."),
+    roles: z.array(z.union([z.string(), z.number()])).optional().describe("Role IDs to assign."),
+    isActive: z.boolean().optional().describe("Whether account is active."),
+    external: z.boolean().optional().describe("Whether admin is external."),
+    notificationsEnabled: z.boolean().optional().describe("Whether notifications are enabled."),
+    password: z.string().optional().describe("New password (if changing)."),
+};
+export const AdminChangePasswordInputSchema = {
+    currentPassword: z.string().describe("Current password."),
+    newPassword: z.string().describe("New password."),
+};
+// Handler functions
+export async function adminList(input) {
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.email)
+        params.append("email", input.email);
+    if (input.isActive !== undefined)
+        params.append("isActive", String(input.isActive));
+    if (input.firstName)
+        params.append("firstName", input.firstName);
+    if (input.lastName)
+        params.append("lastName", input.lastName);
+    if (input.role)
+        params.append("role", input.role);
+    const queryString = params.toString();
+    const url = `/admin${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_admin_list");
+    }
+}
+export async function adminCreate(input) {
+    const payload = {
+        email: input.email,
+        plainPassword: input.password,
+    };
+    if (input.firstName)
+        payload.firstName = input.firstName;
+    if (input.lastName)
+        payload.lastName = input.lastName;
+    if (input.phone)
+        payload.phone = input.phone;
+    if (input.roles)
+        payload.roles = input.roles;
+    if (input.isActive !== undefined)
+        payload.isActive = input.isActive;
+    if (input.external !== undefined)
+        payload.external = input.external;
+    if (input.notificationsEnabled !== undefined)
+        payload.notificationsEnabled = input.notificationsEnabled;
+    try {
+        const response = await apiPost("/admin/data", { admin: payload });
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_admin_create");
+    }
+}
+export async function adminGet(input) {
+    try {
+        const response = await apiGet(`/admin/data/${input.adminId}`);
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_admin_get");
+    }
+}
+export async function adminUpdate(input) {
+    const payload = {};
+    if (input.email)
+        payload.email = input.email;
+    if (input.firstName)
+        payload.firstName = input.firstName;
+    if (input.lastName)
+        payload.lastName = input.lastName;
+    if (input.phone)
+        payload.phone = input.phone;
+    if (input.roles)
+        payload.roles = input.roles;
+    if (input.isActive !== undefined)
+        payload.isActive = input.isActive;
+    if (input.external !== undefined)
+        payload.external = input.external;
+    if (input.notificationsEnabled !== undefined)
+        payload.notificationsEnabled = input.notificationsEnabled;
+    if (input.password)
+        payload.plainPassword = input.password;
+    try {
+        const response = await apiPut(`/admin/data/${input.adminId}`, { admin: payload });
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_admin_update");
+    }
+}
+export async function adminChangePassword(input) {
+    try {
+        await apiPut("/admin/password", {
+            currentPassword: input.currentPassword,
+            plainPassword: input.newPassword,
+        });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_admin_change_password");
+    }
+}
+export async function adminGetPermissions() {
+    try {
+        const response = await apiGet("/admin/permissions");
+        return response;
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_admin_get_permissions");
+    }
+}
+// Tool definitions
+export const adminToolDefinitions = [
+    {
+        name: "openloyalty_admin_list",
+        description: "List admin users with optional filtering. Returns paginated list of admin users with id, email, firstName, lastName, isActive, createdAt.",
+        inputSchema: AdminListInputSchema,
+        handler: adminList,
+    },
+    {
+        name: "openloyalty_admin_create",
+        description: "Create a new admin user. Requires email and password. Optionally assign roles, set active status, and configure notifications. Returns adminId.",
+        inputSchema: AdminCreateInputSchema,
+        handler: adminCreate,
+    },
+    {
+        name: "openloyalty_admin_get",
+        description: "Get full admin user details by ID. Returns profile including email, name, roles, settings, active status, and creation date.",
+        inputSchema: AdminGetInputSchema,
+        handler: adminGet,
+    },
+    {
+        name: "openloyalty_admin_update",
+        description: "Update admin user profile. Can update email, name, phone, roles, active status, and password. Returns adminId on success.",
+        inputSchema: AdminUpdateInputSchema,
+        handler: adminUpdate,
+    },
+    {
+        name: "openloyalty_admin_change_password",
+        description: "Change the currently logged-in admin's password. Requires current password for verification. Returns void on success.",
+        inputSchema: AdminChangePasswordInputSchema,
+        handler: adminChangePassword,
+    },
+    {
+        name: "openloyalty_admin_get_permissions",
+        description: "Get the current admin user's permissions. Returns superAdmin flag, list of roles, and list of permission strings. Use to check what actions are available.",
+        inputSchema: {},
+        handler: adminGetPermissions,
+    },
+];