@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/platform/api/webhook.js

@@ -0,0 +1,124 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+
+//#region src/platform/api/webhook.ts
+/**
+* Payment Webhook API
+*
+* Handles manual payment verification/rejection for superadmins.
+*
+* Routes:
+* - POST /webhooks/payments/manual/verify - Verify manual payment (superadmin)
+* - POST /webhooks/payments/manual/reject - Reject manual payment (superadmin)
+*
+* Note: Provider webhooks (POST /webhooks/payments/:provider) are called
+* directly by payment providers (Stripe, SSLCommerz, etc.) and don't need
+* a frontend client method.
+*/
+var WebhookApi = class {
+	constructor() {
+		this.baseUrl = "/webhooks/payments";
+	}
+	/**
+	* Verify a manual payment (superadmin only)
+	* POST /webhooks/payments/manual/verify
+	*
+	* Flow:
+	* 1. Customer places order with manual payment (cash, bKash, Nagad, bank)
+	* 2. Customer pays and provides transaction reference
+	* 3. Admin verifies payment via this endpoint
+	* 4. Transaction status -> 'verified'
+	* 5. Order payment status -> 'verified', order status -> 'confirmed'
+	*
+	* @param params.transactionId - Transaction ID to verify
+	* @param params.notes - Optional verification notes
+	* @param params.token - Auth token (superadmin required)
+	* @param params.options - Additional fetch options
+	* @returns Verification result with transaction details
+	*
+	* @example
+	* ```typescript
+	* const result = await webhookApi.verifyPayment({
+	*   token: adminToken,
+	*   transactionId: '507f1f77bcf86cd799439011',
+	*   notes: 'Verified bKash TrxID via app',
+	* });
+	* ```
+	*/
+	async verifyPayment({ token, transactionId, notes, options = {} }) {
+		if (!transactionId) throw new Error("Transaction ID is required");
+		if (!token) throw new Error("Authentication required");
+		const body = { transactionId };
+		if (notes) body.notes = notes;
+		return handleApiRequest("POST", `${this.baseUrl}/manual/verify`, {
+			token,
+			body,
+			cache: "no-store",
+			...options
+		});
+	}
+	/**
+	* Reject a manual payment (superadmin only)
+	* POST /webhooks/payments/manual/reject
+	*
+	* Flow:
+	* 1. Customer claims to have paid but admin finds issue
+	* 2. Admin rejects payment with reason via this endpoint
+	* 3. Transaction status -> 'failed', failureReason recorded
+	* 4. Order payment status -> 'failed'
+	*
+	* Common rejection reasons:
+	* - Invalid transaction reference
+	* - Amount mismatch
+	* - Duplicate claim
+	* - Suspected fraud
+	* - Payment not received
+	*
+	* @param params.transactionId - Transaction ID to reject
+	* @param params.reason - Rejection reason (required)
+	* @param params.token - Auth token (superadmin required)
+	* @param params.options - Additional fetch options
+	* @returns Rejection result with failure details
+	*
+	* @example
+	* ```typescript
+	* const result = await webhookApi.rejectPayment({
+	*   token: adminToken,
+	*   transactionId: '507f1f77bcf86cd799439011',
+	*   reason: 'Invalid bKash TrxID - no matching transaction found',
+	* });
+	* ```
+	*/
+	async rejectPayment({ token, transactionId, reason, options = {} }) {
+		if (!transactionId) throw new Error("Transaction ID is required");
+		if (!reason) throw new Error("Rejection reason is required");
+		if (!token) throw new Error("Authentication required");
+		const body = {
+			transactionId,
+			reason
+		};
+		return handleApiRequest("POST", `${this.baseUrl}/manual/reject`, {
+			token,
+			body,
+			cache: "no-store",
+			...options
+		});
+	}
+	/**
+	* Alias for verifyPayment - more explicit naming
+	* @deprecated Use verifyPayment instead
+	*/
+	async verifyManualPayment(params) {
+		return this.verifyPayment(params);
+	}
+	/**
+	* Alias for rejectPayment - more explicit naming
+	* @deprecated Use rejectPayment instead
+	*/
+	async rejectManualPayment(params) {
+		return this.rejectPayment(params);
+	}
+};
+const webhookApi = new WebhookApi();
+
+//#endregion
+export { WebhookApi, webhookApi };

package/dist/platform/hooks/branch.d.ts

@@ -0,0 +1,24 @@
+import { Branch, CreateBranchPayload, UpdateBranchPayload } from "../types/branch.js";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/platform/hooks/branch.d.ts
+/**
+ * Branch hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useBranches: List branches with filtering/pagination
+ * - useBranchDetail: Get single branch
+ * - useBranchActions: Create, update, delete mutations
+ * - useBranchNavigation: Navigation between branches
+ */
+declare const branchHooks: _classytic_arc_next0.CrudHooksReturn<Branch, CreateBranchPayload, UpdateBranchPayload>;
+declare const BRANCH_KEYS: _classytic_arc_next_query0.QueryKeys, useBranches: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Branch> | undefined): _classytic_arc_next_query0.ListQueryResult<Branch>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Branch> | undefined): _classytic_arc_next_query0.ListQueryResult<Branch>;
+  }, useBranchDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Branch> | undefined): _classytic_arc_next_query0.DetailQueryResult<Branch>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Branch> | undefined): _classytic_arc_next_query0.DetailQueryResult<Branch>;
+  }, useBranchActions: () => _classytic_arc_next0.CrudActions<Branch, CreateBranchPayload, UpdateBranchPayload>, useBranchNavigation: () => _classytic_arc_next0.NavigateFn<Branch>;
+//#endregion
+export { BRANCH_KEYS, branchHooks, useBranchActions, useBranchDetail, useBranchNavigation, useBranches };

package/dist/platform/hooks/branch.js

@@ -0,0 +1,31 @@
+"use client";
+
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { branchApi } from "../api/branch.js";
+
+//#region src/platform/hooks/branch.ts
+/**
+* Branch Hooks
+*
+* React hooks for branch CRUD operations using the factory pattern.
+*/
+/**
+* Branch hooks using createCrudHooks factory
+*
+* Provides:
+* - useBranches: List branches with filtering/pagination
+* - useBranchDetail: Get single branch
+* - useBranchActions: Create, update, delete mutations
+* - useBranchNavigation: Navigation between branches
+*/
+const branchHooks = createCrudHooks({
+	api: branchApi,
+	entityKey: "branches",
+	singular: "Branch",
+	plural: "Branches",
+	defaults: { staleTime: 900 * 1e3 }
+});
+const { KEYS: BRANCH_KEYS, useList: useBranches, useDetail: useBranchDetail, useActions: useBranchActions, useNavigation: useBranchNavigation } = branchHooks;
+
+//#endregion
+export { BRANCH_KEYS, branchHooks, useBranchActions, useBranchDetail, useBranchNavigation, useBranches };

package/dist/platform/hooks/config.d.ts

@@ -0,0 +1,61 @@
+import { QueryKeys } from "../../core/react/query.factory.js";
+import { PlatformConfig, UpdatePlatformConfigPayload } from "../types/config.js";
+import { PermissionMatrix } from "../api/config.js";
+
+//#region src/platform/hooks/config.d.ts
+declare const PLATFORM_KEYS: QueryKeys;
+interface QueryOptions {
+  enabled?: boolean;
+  staleTime?: number;
+}
+interface UsePlatformConfigReturn {
+  config: PlatformConfig | null;
+  isLoading: boolean;
+  isFetching: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+interface UsePaymentMethodsReturn {
+  paymentMethods: PlatformConfig["paymentMethods"] | null;
+  isLoading: boolean;
+}
+interface UseDeliveryZonesReturn {
+  deliveryZones: NonNullable<PlatformConfig["checkout"]>["deliveryZones"] | null;
+  isLoading: boolean;
+}
+interface UseMembershipConfigReturn {
+  membershipConfig: PlatformConfig["membership"] | null;
+  isLoading: boolean;
+}
+interface UseUpdatePlatformConfigReturn {
+  updateConfig: (data: UpdatePlatformConfigPayload) => Promise<unknown>;
+  isUpdating: boolean;
+}
+/**
+ * Get full platform configuration.
+ */
+declare function usePlatformConfig(options?: QueryOptions): UsePlatformConfigReturn;
+/**
+ * Update platform configuration (admin only).
+ */
+declare function useUpdatePlatformConfig(): UseUpdatePlatformConfigReturn;
+/** Get payment methods from platform config */
+declare function usePaymentMethods(options?: QueryOptions): UsePaymentMethodsReturn;
+/** Get delivery zones from platform config */
+declare function useDeliveryZones(options?: QueryOptions): UseDeliveryZonesReturn;
+/** Get membership config from platform config */
+declare function useMembershipConfig(options?: QueryOptions): UseMembershipConfigReturn;
+declare const PERMISSION_MATRIX_KEYS: QueryKeys;
+interface UsePermissionMatrixReturn {
+  matrix: PermissionMatrix | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+/**
+ * Get the full RBAC permission matrix from the backend.
+ * Single source of truth — replaces hardcoded SDK permission groups.
+ * Cached for 30 minutes (permission config is static).
+ */
+declare function usePermissionMatrix(options?: QueryOptions): UsePermissionMatrixReturn;
+//#endregion
+export { PERMISSION_MATRIX_KEYS, PLATFORM_KEYS, UseDeliveryZonesReturn, UseMembershipConfigReturn, UsePaymentMethodsReturn, UsePermissionMatrixReturn, UsePlatformConfigReturn, UseUpdatePlatformConfigReturn, useDeliveryZones, useMembershipConfig, usePaymentMethods, usePermissionMatrix, usePlatformConfig, useUpdatePlatformConfig };

package/dist/platform/hooks/config.js

@@ -0,0 +1,100 @@
+"use client";
+
+import { useMutationWithTransition } from "../../core/react/mutation.factory.js";
+import { createQueryKeys } from "../../core/react/query.factory.js";
+import { platformConfigApi } from "../api/config.js";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/platform/hooks/config.ts
+/**
+* Platform Configuration Hooks
+*
+* Hooks for platform configuration management.
+* Primary source for: payment methods, checkout, VAT, delivery zones, membership.
+*/
+const PLATFORM_KEYS = createQueryKeys("platform-config");
+/**
+* Get full platform configuration.
+*/
+function usePlatformConfig(options = {}) {
+	const { data, isLoading, isFetching, error, refetch } = useQuery({
+		queryKey: PLATFORM_KEYS.detail("config"),
+		queryFn: async () => {
+			return (await platformConfigApi.getConfig()).data ?? null;
+		},
+		enabled: options.enabled !== false,
+		staleTime: options.staleTime ?? 300 * 1e3
+	});
+	return {
+		config: data ?? null,
+		isLoading,
+		isFetching,
+		error,
+		refetch
+	};
+}
+/**
+* Update platform configuration (admin only).
+*/
+function useUpdatePlatformConfig() {
+	const mutation = useMutationWithTransition({
+		mutationFn: (data) => platformConfigApi.updateConfig({ data }),
+		invalidateQueries: [PLATFORM_KEYS.all],
+		messages: {
+			success: "Configuration updated successfully",
+			error: "Failed to update configuration"
+		}
+	});
+	return {
+		updateConfig: mutation.mutateAsync,
+		isUpdating: mutation.isPending
+	};
+}
+/** Get payment methods from platform config */
+function usePaymentMethods(options = {}) {
+	const { config, isLoading } = usePlatformConfig(options);
+	return {
+		paymentMethods: config?.paymentMethods ?? null,
+		isLoading
+	};
+}
+/** Get delivery zones from platform config */
+function useDeliveryZones(options = {}) {
+	const { config, isLoading } = usePlatformConfig(options);
+	return {
+		deliveryZones: config?.checkout?.deliveryZones ?? null,
+		isLoading
+	};
+}
+/** Get membership config from platform config */
+function useMembershipConfig(options = {}) {
+	const { config, isLoading } = usePlatformConfig(options);
+	return {
+		membershipConfig: config?.membership ?? null,
+		isLoading
+	};
+}
+const PERMISSION_MATRIX_KEYS = createQueryKeys("permission-matrix");
+/**
+* Get the full RBAC permission matrix from the backend.
+* Single source of truth — replaces hardcoded SDK permission groups.
+* Cached for 30 minutes (permission config is static).
+*/
+function usePermissionMatrix(options = {}) {
+	const { data, isLoading, error } = useQuery({
+		queryKey: PERMISSION_MATRIX_KEYS.detail("full"),
+		queryFn: async () => {
+			return (await platformConfigApi.getPermissionMatrix()).data ?? null;
+		},
+		enabled: options.enabled !== false,
+		staleTime: options.staleTime ?? 1800 * 1e3
+	});
+	return {
+		matrix: data ?? null,
+		isLoading,
+		error
+	};
+}
+
+//#endregion
+export { PERMISSION_MATRIX_KEYS, PLATFORM_KEYS, useDeliveryZones, useMembershipConfig, usePaymentMethods, usePermissionMatrix, usePlatformConfig, useUpdatePlatformConfig };

package/dist/platform/hooks/features.d.ts

@@ -0,0 +1,22 @@
+import { FeatureManifest, FeatureStatus, FeatureTier, PlanInfo } from "../types/features.js";
+
+//#region src/platform/hooks/features.d.ts
+declare const FEATURE_KEYS: {
+  manifest: readonly ["features", "manifest"];
+};
+declare function useFeatures(): {
+  /** Full manifest */manifest: FeatureManifest | undefined; /** Deployment plan info */
+  plan: PlanInfo; /** Whether deployment is on trial */
+  isTrial: boolean; /** Whether deployment is on a paid plan */
+  isPaid: boolean; /** Check if a feature is enabled (any tier) */
+  isEnabled: (featureId: string) => boolean; /** Get feature-level status (active, trial, disabled, expired, upgrade_required) */
+  getStatus: (featureId: string) => FeatureStatus; /** Check if feature meets a minimum tier (e.g. "standard") */
+  hasTier: (featureId: string, minTier: FeatureTier) => boolean; /** Check if a specific capability is available */
+  hasCapability: (featureId: string, capability: string) => boolean; /** Get the resolved tier for a feature */
+  getTier: (featureId: string) => FeatureTier | null; /** Get all capabilities for a feature */
+  getCapabilities: (featureId: string) => string[]; /** List of enabled feature IDs */
+  enabled: string[];
+  isLoading: boolean;
+};
+//#endregion
+export { FEATURE_KEYS, useFeatures };

package/dist/platform/hooks/features.js

@@ -0,0 +1,75 @@
+"use client";
+
+import { featuresApi } from "../api/features.js";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+//#region src/platform/hooks/features.ts
+/**
+* Feature License Hook
+*
+* Fetches the deployment's feature manifest once on app boot.
+* Supports tier-based gating, plan status, and feature-level status.
+*
+* @example
+* ```tsx
+* const { isEnabled, plan, getStatus } = useFeatures();
+*
+* if (!isEnabled("loyalty")) return null;
+* if (plan.status === "trial") showTrialBanner();
+* if (getStatus("warehouse") === "upgrade_required") showUpgradePrompt();
+* ```
+*/
+const FEATURE_KEYS = { manifest: ["features", "manifest"] };
+const TIER_RANK = {
+	basic: 0,
+	standard: 1,
+	enterprise: 2
+};
+const DEFAULT_PLAN = {
+	status: "trial",
+	name: "Trial",
+	expiresAt: null,
+	daysRemaining: -1
+};
+function useFeatures() {
+	const query = useQuery({
+		queryKey: FEATURE_KEYS.manifest,
+		queryFn: async () => {
+			return (await featuresApi.getManifest()).data;
+		},
+		staleTime: 600 * 1e3,
+		gcTime: 1800 * 1e3
+	});
+	const featureMap = useMemo(() => {
+		const map = /* @__PURE__ */ new Map();
+		if (query.data?.features) for (const f of query.data.features) map.set(f.id, f);
+		return map;
+	}, [query.data]);
+	const plan = query.data?.plan ?? DEFAULT_PLAN;
+	return {
+		manifest: query.data,
+		plan,
+		isTrial: plan.status === "trial",
+		isPaid: plan.status === "pro" || plan.status === "enterprise",
+		isEnabled: (featureId) => featureMap.get(featureId)?.enabled ?? false,
+		getStatus: (featureId) => featureMap.get(featureId)?.status ?? "disabled",
+		hasTier: (featureId, minTier) => {
+			const f = featureMap.get(featureId);
+			if (!f?.enabled) return false;
+			return TIER_RANK[f.tier] >= TIER_RANK[minTier];
+		},
+		hasCapability: (featureId, capability) => {
+			const f = featureMap.get(featureId);
+			if (!f?.enabled) return false;
+			return f.capabilities.includes(capability);
+		},
+		getTier: (featureId) => featureMap.get(featureId)?.tier ?? null,
+		getCapabilities: (featureId) => featureMap.get(featureId)?.capabilities ?? [],
+		enabled: query.data?.enabled ?? [],
+		isLoading: query.isLoading
+	};
+}
+
+//#endregion
+export { FEATURE_KEYS, useFeatures };

package/dist/platform/hooks/index.d.ts

@@ -0,0 +1,6 @@
+import { FeatureManifest, FeatureTier, ResolvedFeature } from "../types/features.js";
+import { PERMISSION_MATRIX_KEYS, PLATFORM_KEYS, UseDeliveryZonesReturn, UseMembershipConfigReturn, UsePaymentMethodsReturn, UsePermissionMatrixReturn, UsePlatformConfigReturn, UseUpdatePlatformConfigReturn, useDeliveryZones, useMembershipConfig, usePaymentMethods, usePermissionMatrix, usePlatformConfig, useUpdatePlatformConfig } from "./config.js";
+import { BRANCH_KEYS, branchHooks, useBranchActions, useBranchDetail, useBranchNavigation, useBranches } from "./branch.js";
+import { USER_KEYS, useUserActions, useUserDetail, useUserNavigation, useUsers, userHooks } from "./user.js";
+import { EVALUATION_KEYS, PROGRAM_KEYS, VOUCHER_KEYS, programHooks, useFullProgram, useProgramActions, useProgramDetail, useProgramNavigation, useProgramRewards, useProgramRules, useProgramTransition, usePrograms, usePromoCommit, usePromoEvaluate, usePromoPreview, usePromoRollback, useVoucherCancel, useVoucherGenerate, useVoucherGenerateSingle, useVoucherValidate } from "./promo.js";
+import { FEATURE_KEYS, useFeatures } from "./features.js";

package/dist/platform/hooks/promo.d.ts

@@ -0,0 +1,218 @@
+import { CommitResult, CreateProgramPayload, CreateRewardPayload, CreateRulePayload, EvaluateInput, EvaluationResult, FullProgram, GenerateCodesPayload, GenerateSingleCodePayload, Program, ProgramTransitionAction, Reward, Rule, UpdateRewardPayload, UpdateRulePayload, Voucher, VoucherValidation } from "../types/promo.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/platform/hooks/promo.d.ts
+declare const programHooks: _classytic_arc_next0.CrudHooksReturn<Program, CreateProgramPayload, Partial<CreateProgramPayload>>;
+declare const PROGRAM_KEYS: _classytic_arc_next_query0.QueryKeys, usePrograms: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Program> | undefined): _classytic_arc_next_query0.ListQueryResult<Program>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Program> | undefined): _classytic_arc_next_query0.ListQueryResult<Program>;
+  }, useProgramDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Program> | undefined): _classytic_arc_next_query0.DetailQueryResult<Program>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Program> | undefined): _classytic_arc_next_query0.DetailQueryResult<Program>;
+  }, useProgramActions: () => _classytic_arc_next0.CrudActions<Program, CreateProgramPayload, Partial<CreateProgramPayload>>, useProgramNavigation: () => _classytic_arc_next0.NavigateFn<Program>;
+/**
+ * Fetch a program with its rules and rewards pre-loaded
+ *
+ * @example
+ * ```tsx
+ * const { data: program, isLoading } = useFullProgram(token, programId);
+ * console.log(program?.rules, program?.rewards);
+ * ```
+ */
+declare function useFullProgram(token: string, id: string | undefined, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<FullProgram, Error>;
+/**
+ * Transition a program status (activate / pause / archive)
+ *
+ * @example
+ * ```tsx
+ * const { transition, isTransitioning } = useProgramTransition(token);
+ * await transition({ id: programId, action: "activate" });
+ * ```
+ */
+declare function useProgramTransition(token: string): {
+  transition: _tanstack_react_query0.UseMutateAsyncFunction<Program, Error, {
+    id: string;
+    action: ProgramTransitionAction;
+  }, unknown>;
+  isTransitioning: boolean;
+};
+/**
+ * CRUD mutations for rules on a program
+ *
+ * @example
+ * ```tsx
+ * const { addRule, updateRule, removeRule } = useProgramRules(token);
+ * await addRule({ programId, data: { minimumAmount: 500 } });
+ * ```
+ */
+declare function useProgramRules(token: string): {
+  addRule: _tanstack_react_query0.UseMutateAsyncFunction<Rule, Error, {
+    programId: string;
+    data: CreateRulePayload;
+  }, unknown>;
+  isAddingRule: boolean;
+  updateRule: _tanstack_react_query0.UseMutateAsyncFunction<Rule, Error, {
+    programId: string;
+    ruleId: string;
+    data: UpdateRulePayload;
+  }, unknown>;
+  isUpdatingRule: boolean;
+  removeRule: _tanstack_react_query0.UseMutateAsyncFunction<void, Error, {
+    programId: string;
+    ruleId: string;
+  }, unknown>;
+  isRemovingRule: boolean;
+};
+/**
+ * CRUD mutations for rewards on a program
+ *
+ * @example
+ * ```tsx
+ * const { addReward, updateReward, removeReward } = useProgramRewards(token);
+ * await addReward({ programId, data: { rewardType: 'discount', discountMode: 'percentage', discountAmount: 10 } });
+ * ```
+ */
+declare function useProgramRewards(token: string): {
+  addReward: _tanstack_react_query0.UseMutateAsyncFunction<Reward, Error, {
+    programId: string;
+    data: CreateRewardPayload;
+  }, unknown>;
+  isAddingReward: boolean;
+  updateReward: _tanstack_react_query0.UseMutateAsyncFunction<Reward, Error, {
+    programId: string;
+    rewardId: string;
+    data: UpdateRewardPayload;
+  }, unknown>;
+  isUpdatingReward: boolean;
+  removeReward: _tanstack_react_query0.UseMutateAsyncFunction<void, Error, {
+    programId: string;
+    rewardId: string;
+  }, unknown>;
+  isRemovingReward: boolean;
+};
+declare const VOUCHER_KEYS: {
+  all: readonly ["vouchers"];
+  detail: (id: string) => readonly ["vouchers", string];
+  byCode: (code: string) => readonly ["vouchers", "code", string];
+};
+/**
+ * Batch-generate voucher codes
+ *
+ * @example
+ * ```tsx
+ * const { generate, isGenerating } = useVoucherGenerate(token);
+ * const vouchers = await generate({ programId, count: 50 });
+ * ```
+ */
+declare function useVoucherGenerate(token: string): {
+  generate: _tanstack_react_query0.UseMutateAsyncFunction<Voucher[], Error, GenerateCodesPayload, unknown>;
+  isGenerating: boolean;
+};
+/**
+ * Generate a single voucher code
+ *
+ * @example
+ * ```tsx
+ * const { generateSingle, isGenerating } = useVoucherGenerateSingle(token);
+ * const voucher = await generateSingle({ programId, code: "WELCOME50" });
+ * ```
+ */
+declare function useVoucherGenerateSingle(token: string): {
+  generateSingle: _tanstack_react_query0.UseMutateAsyncFunction<Voucher, Error, GenerateSingleCodePayload, unknown>;
+  isGenerating: boolean;
+};
+/**
+ * Validate a voucher code
+ *
+ * @example
+ * ```tsx
+ * const { validate, isValidating } = useVoucherValidate(token);
+ * const result = await validate("SUMMER20");
+ * if (result.valid) { ... }
+ * ```
+ */
+declare function useVoucherValidate(token: string): {
+  validate: _tanstack_react_query0.UseMutateAsyncFunction<VoucherValidation, Error, string, unknown>;
+  isValidating: boolean;
+  result: VoucherValidation | undefined;
+};
+/**
+ * Cancel a voucher
+ *
+ * @example
+ * ```tsx
+ * const { cancel, isCancelling } = useVoucherCancel(token);
+ * await cancel(voucherId);
+ * ```
+ */
+declare function useVoucherCancel(token: string): {
+  cancel: _tanstack_react_query0.UseMutateAsyncFunction<Voucher, Error, string, unknown>;
+  isCancelling: boolean;
+};
+declare const EVALUATION_KEYS: {
+  all: readonly ["evaluations"];
+};
+/**
+ * Preview promo evaluation (dry-run, no side effects)
+ *
+ * @example
+ * ```tsx
+ * const { preview, isPreviewing, result } = usePromoPreview(token);
+ * const evaluation = await preview({ items, subtotal: 1500, codes: ["SUMMER20"] });
+ * ```
+ */
+declare function usePromoPreview(token: string): {
+  preview: _tanstack_react_query0.UseMutateAsyncFunction<EvaluationResult, Error, EvaluateInput, unknown>;
+  isPreviewing: boolean;
+  result: EvaluationResult | undefined;
+};
+/**
+ * Evaluate cart (reserves usage counts, must be committed or rolled back)
+ *
+ * @example
+ * ```tsx
+ * const { evaluate, isEvaluating } = usePromoEvaluate(token);
+ * const result = await evaluate({ items, subtotal: 1500, codes: ["SUMMER20"] });
+ * // Later: commit or rollback
+ * ```
+ */
+declare function usePromoEvaluate(token: string): {
+  evaluate: _tanstack_react_query0.UseMutateAsyncFunction<EvaluationResult, Error, EvaluateInput, unknown>;
+  isEvaluating: boolean;
+  result: EvaluationResult | undefined;
+};
+/**
+ * Commit an evaluation to an order
+ *
+ * @example
+ * ```tsx
+ * const { commit, isCommitting } = usePromoCommit(token);
+ * await commit({ evaluationId, orderId });
+ * ```
+ */
+declare function usePromoCommit(token: string): {
+  commit: _tanstack_react_query0.UseMutateAsyncFunction<CommitResult, Error, {
+    evaluationId: string;
+    orderId: string;
+  }, unknown>;
+  isCommitting: boolean;
+};
+/**
+ * Rollback an uncommitted evaluation
+ *
+ * @example
+ * ```tsx
+ * const { rollback, isRollingBack } = usePromoRollback(token);
+ * await rollback(evaluationId);
+ * ```
+ */
+declare function usePromoRollback(token: string): {
+  rollback: _tanstack_react_query0.UseMutateAsyncFunction<void, Error, string, unknown>;
+  isRollingBack: boolean;
+};
+//#endregion
+export { EVALUATION_KEYS, PROGRAM_KEYS, VOUCHER_KEYS, programHooks, useFullProgram, useProgramActions, useProgramDetail, useProgramNavigation, useProgramRewards, useProgramRules, useProgramTransition, usePrograms, usePromoCommit, usePromoEvaluate, usePromoPreview, usePromoRollback, useVoucherCancel, useVoucherGenerate, useVoucherGenerateSingle, useVoucherValidate };