@classytic/revenue 1.1.2 → 1.1.4

package/dist/schemas/validation.d.mts

@@ -0,0 +1,375 @@
+import * as z from "zod";
+
+//#region src/schemas/validation.d.ts
+/**
+ * MongoDB ObjectId pattern
+ */
+declare const ObjectIdSchema: z.ZodString;
+/**
+ * Currency code (ISO 4217)
+ */
+declare const CurrencySchema: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+/**
+ * Money amount in smallest unit (cents, paisa)
+ */
+declare const MoneyAmountSchema: z.ZodNumber;
+/**
+ * Money object
+ */
+declare const MoneySchema: z.ZodObject<{
+  amount: z.ZodNumber;
+  currency: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Email address
+ */
+declare const EmailSchema: z.ZodString;
+/**
+ * Idempotency key (optional, auto-generated if not provided)
+ */
+declare const IdempotencyKeySchema: z.ZodOptional<z.ZodString>;
+/**
+ * Metadata object - Zod v4 record syntax
+ */
+declare const MetadataSchema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+/**
+ * Create payment intent params
+ */
+declare const CreatePaymentSchema: z.ZodObject<{
+  amount: z.ZodNumber;
+  currency: z.ZodDefault<z.ZodString>;
+  customerId: z.ZodString;
+  organizationId: z.ZodString;
+  provider: z.ZodString;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  successUrl: z.ZodOptional<z.ZodString>;
+  cancelUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CreatePaymentInput = z.infer<typeof CreatePaymentSchema>;
+/**
+ * Verify payment params
+ */
+declare const VerifyPaymentSchema: z.ZodObject<{
+  id: z.ZodString;
+  provider: z.ZodOptional<z.ZodString>;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type VerifyPaymentInput = z.infer<typeof VerifyPaymentSchema>;
+/**
+ * Refund params
+ */
+declare const RefundSchema: z.ZodObject<{
+  transactionId: z.ZodString;
+  amount: z.ZodOptional<z.ZodNumber>;
+  reason: z.ZodOptional<z.ZodString>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+type RefundInput = z.infer<typeof RefundSchema>;
+/**
+ * Subscription status
+ */
+declare const SubscriptionStatusSchema: z.ZodEnum<{
+  pending: "pending";
+  cancelled: "cancelled";
+  expired: "expired";
+  active: "active";
+  paused: "paused";
+  past_due: "past_due";
+}>;
+type SubscriptionStatus = z.infer<typeof SubscriptionStatusSchema>;
+/**
+ * Subscription interval
+ */
+declare const IntervalSchema: z.ZodEnum<{
+  day: "day";
+  week: "week";
+  month: "month";
+  year: "year";
+  one_time: "one_time";
+}>;
+type Interval = z.infer<typeof IntervalSchema>;
+/**
+ * Create subscription params
+ */
+declare const CreateSubscriptionSchema: z.ZodObject<{
+  customerId: z.ZodString;
+  organizationId: z.ZodString;
+  planKey: z.ZodString;
+  amount: z.ZodNumber;
+  currency: z.ZodDefault<z.ZodString>;
+  interval: z.ZodDefault<z.ZodEnum<{
+    day: "day";
+    week: "week";
+    month: "month";
+    year: "year";
+    one_time: "one_time";
+  }>>;
+  intervalCount: z.ZodDefault<z.ZodNumber>;
+  provider: z.ZodString;
+  sourceId: z.ZodOptional<z.ZodString>;
+  sourceModel: z.ZodOptional<z.ZodString>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  trialDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type CreateSubscriptionInput = z.infer<typeof CreateSubscriptionSchema>;
+/**
+ * Cancel subscription params
+ */
+declare const CancelSubscriptionSchema: z.ZodObject<{
+  subscriptionId: z.ZodString;
+  immediate: z.ZodDefault<z.ZodBoolean>;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CancelSubscriptionInput = z.infer<typeof CancelSubscriptionSchema>;
+/**
+ * Monetization type
+ */
+declare const MonetizationTypeSchema: z.ZodEnum<{
+  subscription: "subscription";
+  purchase: "purchase";
+  free: "free";
+}>;
+type MonetizationType = z.infer<typeof MonetizationTypeSchema>;
+/**
+ * Create monetization params (unified API)
+ */
+declare const CreateMonetizationSchema: z.ZodObject<{
+  type: z.ZodDefault<z.ZodEnum<{
+    subscription: "subscription";
+    purchase: "purchase";
+    free: "free";
+  }>>;
+  amount: z.ZodOptional<z.ZodNumber>;
+  currency: z.ZodDefault<z.ZodString>;
+  customerId: z.ZodString;
+  organizationId: z.ZodString;
+  provider: z.ZodString;
+  planKey: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  sourceModel: z.ZodOptional<z.ZodString>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  interval: z.ZodOptional<z.ZodEnum<{
+    day: "day";
+    week: "week";
+    month: "month";
+    year: "year";
+    one_time: "one_time";
+  }>>;
+  trialDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type CreateMonetizationInput = z.infer<typeof CreateMonetizationSchema>;
+/**
+ * Commission split recipient
+ */
+declare const SplitRecipientSchema: z.ZodObject<{
+  recipientId: z.ZodString;
+  recipientType: z.ZodDefault<z.ZodString>;
+  percentage: z.ZodNumber;
+  role: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SplitRecipient = z.infer<typeof SplitRecipientSchema>;
+/**
+ * Commission configuration
+ */
+declare const CommissionConfigSchema: z.ZodObject<{
+  platformRate: z.ZodDefault<z.ZodNumber>;
+  gatewayFeeRate: z.ZodDefault<z.ZodNumber>;
+  gatewayFixedFee: z.ZodDefault<z.ZodNumber>;
+  splits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    recipientId: z.ZodString;
+    recipientType: z.ZodDefault<z.ZodString>;
+    percentage: z.ZodNumber;
+    role: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  affiliate: z.ZodOptional<z.ZodObject<{
+    recipientId: z.ZodString;
+    recipientType: z.ZodDefault<z.ZodString>;
+    rate: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type CommissionConfig = z.infer<typeof CommissionConfigSchema>;
+/**
+ * Payment status enum
+ */
+declare const PaymentStatusEnumSchema: z.ZodEnum<{
+  pending: "pending";
+  verified: "verified";
+  failed: "failed";
+  cancelled: "cancelled";
+  refunded: "refunded";
+}>;
+type PaymentStatusEnum = z.infer<typeof PaymentStatusEnumSchema>;
+/**
+ * Individual payment entry for split/multi-payment scenarios
+ * e.g., cash + bank transfer + mobile wallet
+ */
+declare const PaymentEntrySchema: z.ZodObject<{
+  method: z.ZodString;
+  amount: z.ZodNumber;
+  reference: z.ZodOptional<z.ZodString>;
+  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type PaymentEntryInput = z.infer<typeof PaymentEntrySchema>;
+/**
+ * Current payment schema with split payment support
+ * Backward compatible - single payments work without the payments array
+ */
+declare const CurrentPaymentInputSchema: z.ZodObject<{
+  transactionId: z.ZodOptional<z.ZodString>;
+  amount: z.ZodNumber;
+  status: z.ZodDefault<z.ZodEnum<{
+    pending: "pending";
+    verified: "verified";
+    failed: "failed";
+    cancelled: "cancelled";
+    refunded: "refunded";
+  }>>;
+  method: z.ZodString;
+  reference: z.ZodOptional<z.ZodString>;
+  payments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    method: z.ZodString;
+    amount: z.ZodNumber;
+    reference: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>>;
+  verifiedAt: z.ZodOptional<z.ZodDate>;
+  verifiedBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CurrentPaymentInput = z.infer<typeof CurrentPaymentInputSchema>;
+/**
+ * Hold status
+ */
+declare const HoldStatusSchema: z.ZodEnum<{
+  cancelled: "cancelled";
+  held: "held";
+  released: "released";
+  none: "none";
+  partial_release: "partial_release";
+}>;
+type HoldStatus = z.infer<typeof HoldStatusSchema>;
+/**
+ * Create hold params
+ */
+declare const CreateHoldSchema: z.ZodObject<{
+  transactionId: z.ZodString;
+  amount: z.ZodOptional<z.ZodNumber>;
+  holdUntil: z.ZodOptional<z.ZodDate>;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CreateHoldInput = z.infer<typeof CreateHoldSchema>;
+/**
+ * Release hold params
+ */
+declare const ReleaseHoldSchema: z.ZodObject<{
+  transactionId: z.ZodString;
+  amount: z.ZodOptional<z.ZodNumber>;
+  recipientId: z.ZodString;
+  recipientType: z.ZodDefault<z.ZodString>;
+  notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ReleaseHoldInput = z.infer<typeof ReleaseHoldSchema>;
+/**
+ * Provider configuration
+ */
+declare const ProviderConfigSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/**
+ * Retry configuration
+ */
+declare const RetryConfigSchema: z.ZodObject<{
+  maxAttempts: z.ZodDefault<z.ZodNumber>;
+  baseDelay: z.ZodDefault<z.ZodNumber>;
+  maxDelay: z.ZodDefault<z.ZodNumber>;
+  backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+  jitter: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type RetryConfig = z.infer<typeof RetryConfigSchema>;
+/**
+ * Revenue configuration
+ */
+declare const RevenueConfigSchema: z.ZodObject<{
+  defaultCurrency: z.ZodDefault<z.ZodString>;
+  commission: z.ZodOptional<z.ZodObject<{
+    platformRate: z.ZodDefault<z.ZodNumber>;
+    gatewayFeeRate: z.ZodDefault<z.ZodNumber>;
+    gatewayFixedFee: z.ZodDefault<z.ZodNumber>;
+    splits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      recipientId: z.ZodString;
+      recipientType: z.ZodDefault<z.ZodString>;
+      percentage: z.ZodNumber;
+      role: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    affiliate: z.ZodOptional<z.ZodObject<{
+      recipientId: z.ZodString;
+      recipientType: z.ZodDefault<z.ZodString>;
+      rate: z.ZodNumber;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  retry: z.ZodOptional<z.ZodObject<{
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    baseDelay: z.ZodDefault<z.ZodNumber>;
+    maxDelay: z.ZodDefault<z.ZodNumber>;
+    backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    jitter: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  debug: z.ZodDefault<z.ZodBoolean>;
+  environment: z.ZodDefault<z.ZodEnum<{
+    development: "development";
+    staging: "staging";
+    production: "production";
+  }>>;
+}, z.core.$strip>;
+type RevenueConfigInput = z.infer<typeof RevenueConfigSchema>;
+/**
+ * Validate input against schema
+ */
+declare function validate<T extends z.ZodType>(schema: T, data: unknown): z.infer<T>;
+/**
+ * Safe validate (returns result, doesn't throw)
+ */
+declare function safeValidate<T extends z.ZodType>(schema: T, data: unknown): {
+  success: true;
+  data: z.infer<T>;
+} | {
+  success: false;
+  error: z.ZodError;
+};
+/**
+ * Format Zod error for display
+ * Zod v4 uses `issues` property
+ */
+declare function formatZodError(error: z.ZodError): string;
+/**
+ * Validates that split payment totals match the transaction amount
+ * Returns true for single payments (no payments array)
+ *
+ * @param currentPayment - The current payment object to validate
+ * @returns true if valid, false if split totals don't match
+ *
+ * @example
+ * // Single payment - always valid
+ * validateSplitPayments({ amount: 50000, method: 'cash', status: 'verified' }) // true
+ *
+ * // Split payment - totals must match
+ * validateSplitPayments({
+ *   amount: 50000,
+ *   method: 'split',
+ *   status: 'verified',
+ *   payments: [
+ *     { method: 'cash', amount: 10000 },
+ *     { method: 'bkash', amount: 40000 },
+ *   ]
+ * }) // true (10000 + 40000 = 50000)
+ */
+declare function validateSplitPayments(currentPayment: {
+  amount: number;
+  payments?: Array<{
+    amount: number;
+  }>;
+}): boolean;
+//#endregion
+export { CancelSubscriptionInput, CancelSubscriptionSchema, CommissionConfig, CommissionConfigSchema, CreateHoldInput, CreateHoldSchema, CreateMonetizationInput, CreateMonetizationSchema, CreatePaymentInput, CreatePaymentSchema, CreateSubscriptionInput, CreateSubscriptionSchema, CurrencySchema, CurrentPaymentInput, CurrentPaymentInputSchema, EmailSchema, HoldStatus, HoldStatusSchema, IdempotencyKeySchema, Interval, IntervalSchema, MetadataSchema, MonetizationType, MonetizationTypeSchema, MoneyAmountSchema, MoneySchema, ObjectIdSchema, PaymentEntryInput, PaymentEntrySchema, PaymentStatusEnum, PaymentStatusEnumSchema, ProviderConfigSchema, RefundInput, RefundSchema, ReleaseHoldInput, ReleaseHoldSchema, RetryConfig, RetryConfigSchema, RevenueConfigInput, RevenueConfigSchema, SplitRecipient, SplitRecipientSchema, SubscriptionStatus, SubscriptionStatusSchema, VerifyPaymentInput, VerifyPaymentSchema, formatZodError, safeValidate, validate, validateSplitPayments };

package/dist/schemas/validation.mjs

@@ -0,0 +1,325 @@
+import * as z from "zod";
+
+//#region src/schemas/validation.ts
+/**
+* Zod Validation Schemas
+* @classytic/revenue
+*
+* Runtime validation with TypeScript inference
+* Using Zod v4 - Modern schema validation
+*
+* Inspired by: tRPC, Zod best practices
+*/
+/**
+* MongoDB ObjectId pattern
+*/
+const ObjectIdSchema = z.string().regex(/^[a-fA-F0-9]{24}$/, "Invalid ObjectId format");
+/**
+* Currency code (ISO 4217)
+*/
+const CurrencySchema = z.string().length(3, "Currency must be 3 characters").transform((val) => val.toUpperCase()).default("USD");
+/**
+* Money amount in smallest unit (cents, paisa)
+*/
+const MoneyAmountSchema = z.number().int("Amount must be integer (smallest unit)").nonnegative("Amount cannot be negative");
+/**
+* Money object
+*/
+const MoneySchema = z.object({
+	amount: MoneyAmountSchema,
+	currency: z.string().length(3).default("USD")
+});
+/**
+* Email address
+*/
+const EmailSchema = z.string().email();
+/**
+* Idempotency key (optional, auto-generated if not provided)
+*/
+const IdempotencyKeySchema = z.string().min(1).max(255).optional();
+/**
+* Metadata object - Zod v4 record syntax
+*/
+const MetadataSchema = z.record(z.string(), z.unknown()).optional().default({});
+/**
+* Create payment intent params
+*/
+const CreatePaymentSchema = z.object({
+	amount: MoneyAmountSchema,
+	currency: z.string().length(3).default("USD"),
+	customerId: z.string().min(1, "Customer ID is required"),
+	organizationId: z.string().min(1, "Organization ID is required"),
+	provider: z.string().min(1, "Provider is required"),
+	idempotencyKey: IdempotencyKeySchema,
+	description: z.string().optional(),
+	metadata: MetadataSchema,
+	successUrl: z.string().url().optional(),
+	cancelUrl: z.string().url().optional()
+});
+/**
+* Verify payment params
+*/
+const VerifyPaymentSchema = z.object({
+	id: z.string().min(1),
+	provider: z.string().optional(),
+	data: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Refund params
+*/
+const RefundSchema = z.object({
+	transactionId: z.string().min(1),
+	amount: MoneyAmountSchema.optional(),
+	reason: z.string().optional(),
+	idempotencyKey: IdempotencyKeySchema,
+	metadata: MetadataSchema
+});
+/**
+* Subscription status
+*/
+const SubscriptionStatusSchema = z.enum([
+	"pending",
+	"active",
+	"paused",
+	"cancelled",
+	"expired",
+	"past_due"
+]);
+/**
+* Subscription interval
+*/
+const IntervalSchema = z.enum([
+	"day",
+	"week",
+	"month",
+	"year",
+	"one_time"
+]);
+/**
+* Create subscription params
+*/
+const CreateSubscriptionSchema = z.object({
+	customerId: z.string().min(1),
+	organizationId: z.string().min(1),
+	planKey: z.string().min(1),
+	amount: MoneyAmountSchema,
+	currency: z.string().length(3).default("USD"),
+	interval: IntervalSchema.default("month"),
+	intervalCount: z.number().int().positive().default(1),
+	provider: z.string().min(1),
+	sourceId: z.string().optional(),
+	sourceModel: z.string().optional(),
+	idempotencyKey: IdempotencyKeySchema,
+	metadata: MetadataSchema,
+	trialDays: z.number().int().nonnegative().optional()
+});
+/**
+* Cancel subscription params
+*/
+const CancelSubscriptionSchema = z.object({
+	subscriptionId: z.string().min(1),
+	immediate: z.boolean().default(false),
+	reason: z.string().optional()
+});
+/**
+* Monetization type
+*/
+const MonetizationTypeSchema = z.enum([
+	"purchase",
+	"subscription",
+	"free"
+]);
+/**
+* Create monetization params (unified API)
+*/
+const CreateMonetizationSchema = z.object({
+	type: MonetizationTypeSchema.default("purchase"),
+	amount: MoneyAmountSchema.optional(),
+	currency: z.string().length(3).default("USD"),
+	customerId: z.string().min(1),
+	organizationId: z.string().min(1),
+	provider: z.string().min(1),
+	planKey: z.string().optional(),
+	sourceId: z.string().optional(),
+	sourceModel: z.string().optional(),
+	idempotencyKey: IdempotencyKeySchema,
+	metadata: MetadataSchema,
+	interval: IntervalSchema.optional(),
+	trialDays: z.number().int().nonnegative().optional()
+}).refine((data) => {
+	if (data.type !== "free" && !data.amount) return false;
+	return true;
+}, { message: "Amount is required for non-free monetization types" });
+/**
+* Commission split recipient
+*/
+const SplitRecipientSchema = z.object({
+	recipientId: z.string().min(1),
+	recipientType: z.string().default("user"),
+	percentage: z.number().min(0).max(1),
+	role: z.string().optional()
+});
+/**
+* Commission configuration
+*/
+const CommissionConfigSchema = z.object({
+	platformRate: z.number().min(0).max(1).default(0),
+	gatewayFeeRate: z.number().min(0).max(1).default(0),
+	gatewayFixedFee: MoneyAmountSchema.default(0),
+	splits: z.array(SplitRecipientSchema).optional(),
+	affiliate: z.object({
+		recipientId: z.string(),
+		recipientType: z.string().default("user"),
+		rate: z.number().min(0).max(1)
+	}).optional()
+});
+/**
+* Payment status enum
+*/
+const PaymentStatusEnumSchema = z.enum([
+	"pending",
+	"verified",
+	"failed",
+	"refunded",
+	"cancelled"
+]);
+/**
+* Individual payment entry for split/multi-payment scenarios
+* e.g., cash + bank transfer + mobile wallet
+*/
+const PaymentEntrySchema = z.object({
+	method: z.string().min(1, "Payment method is required"),
+	amount: MoneyAmountSchema,
+	reference: z.string().optional(),
+	details: z.record(z.string(), z.unknown()).optional()
+});
+/**
+* Current payment schema with split payment support
+* Backward compatible - single payments work without the payments array
+*/
+const CurrentPaymentInputSchema = z.object({
+	transactionId: z.string().optional(),
+	amount: MoneyAmountSchema,
+	status: PaymentStatusEnumSchema.default("pending"),
+	method: z.string().min(1, "Payment method is required"),
+	reference: z.string().optional(),
+	payments: z.array(PaymentEntrySchema).optional(),
+	verifiedAt: z.date().optional(),
+	verifiedBy: z.string().optional()
+}).refine((data) => {
+	if (data.payments && data.payments.length > 0) return data.payments.reduce((sum, p) => sum + p.amount, 0) === data.amount;
+	return true;
+}, { message: "Split payments total must equal the transaction amount" });
+/**
+* Hold status
+*/
+const HoldStatusSchema = z.enum([
+	"none",
+	"held",
+	"partial_release",
+	"released",
+	"cancelled"
+]);
+/**
+* Create hold params
+*/
+const CreateHoldSchema = z.object({
+	transactionId: z.string().min(1),
+	amount: MoneyAmountSchema.optional(),
+	holdUntil: z.date().optional(),
+	reason: z.string().optional()
+});
+/**
+* Release hold params
+*/
+const ReleaseHoldSchema = z.object({
+	transactionId: z.string().min(1),
+	amount: MoneyAmountSchema.optional(),
+	recipientId: z.string().min(1),
+	recipientType: z.string().default("user"),
+	notes: z.string().optional()
+});
+/**
+* Provider configuration
+*/
+const ProviderConfigSchema = z.record(z.string(), z.unknown());
+/**
+* Retry configuration
+*/
+const RetryConfigSchema = z.object({
+	maxAttempts: z.number().int().positive().default(3),
+	baseDelay: z.number().positive().default(1e3),
+	maxDelay: z.number().positive().default(3e4),
+	backoffMultiplier: z.number().positive().default(2),
+	jitter: z.number().min(0).max(1).default(.1)
+});
+/**
+* Revenue configuration
+*/
+const RevenueConfigSchema = z.object({
+	defaultCurrency: z.string().length(3).default("USD"),
+	commission: CommissionConfigSchema.optional(),
+	retry: RetryConfigSchema.optional(),
+	debug: z.boolean().default(false),
+	environment: z.enum([
+		"development",
+		"staging",
+		"production"
+	]).default("development")
+});
+/**
+* Validate input against schema
+*/
+function validate(schema, data) {
+	return schema.parse(data);
+}
+/**
+* Safe validate (returns result, doesn't throw)
+*/
+function safeValidate(schema, data) {
+	const result = schema.safeParse(data);
+	if (result.success) return {
+		success: true,
+		data: result.data
+	};
+	return {
+		success: false,
+		error: result.error
+	};
+}
+/**
+* Format Zod error for display
+* Zod v4 uses `issues` property
+*/
+function formatZodError(error) {
+	return error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+}
+/**
+* Validates that split payment totals match the transaction amount
+* Returns true for single payments (no payments array)
+*
+* @param currentPayment - The current payment object to validate
+* @returns true if valid, false if split totals don't match
+*
+* @example
+* // Single payment - always valid
+* validateSplitPayments({ amount: 50000, method: 'cash', status: 'verified' }) // true
+*
+* // Split payment - totals must match
+* validateSplitPayments({
+*   amount: 50000,
+*   method: 'split',
+*   status: 'verified',
+*   payments: [
+*     { method: 'cash', amount: 10000 },
+*     { method: 'bkash', amount: 40000 },
+*   ]
+* }) // true (10000 + 40000 = 50000)
+*/
+function validateSplitPayments(currentPayment) {
+	if (!currentPayment.payments?.length) return true;
+	return currentPayment.payments.reduce((sum, p) => sum + p.amount, 0) === currentPayment.amount;
+}
+
+//#endregion
+export { CancelSubscriptionSchema, CommissionConfigSchema, CreateHoldSchema, CreateMonetizationSchema, CreatePaymentSchema, CreateSubscriptionSchema, CurrencySchema, CurrentPaymentInputSchema, EmailSchema, HoldStatusSchema, IdempotencyKeySchema, IntervalSchema, MetadataSchema, MonetizationTypeSchema, MoneyAmountSchema, MoneySchema, ObjectIdSchema, PaymentEntrySchema, PaymentStatusEnumSchema, ProviderConfigSchema, RefundSchema, ReleaseHoldSchema, RetryConfigSchema, RevenueConfigSchema, SplitRecipientSchema, SubscriptionStatusSchema, VerifyPaymentSchema, formatZodError, safeValidate, validate, validateSplitPayments };