pecunia-core 0.0.0

package/dist/get-payment-tables-0FkEj3dw.mjs

@@ -0,0 +1,3677 @@
+import { C as ScheduleStatus, D as TransactionStatus, E as SubscriptionStatus, M as WebHookEventStatus, O as TransactionType, S as ProrationBehavior, T as ScheduledTaskType, _ as PaymentIntentStatus, b as PricingModel, c as BillingInterval, d as CollectionMethod, f as Currency, h as InvoiceStatus, j as WebHookDeliveryTrigger, k as UsageAction, l as CheckoutSessionMode, n as PecuniaError, o as Actor, s as AuditAction, u as CheckoutSessionStatus, v as PaymentProviders, w as ScheduledTaskStatus, y as PriceType } from "./errors-vpD21Iku.mjs";
+import { t as generateId } from "./generate-id-D3ZvbbXn.mjs";
+import { z } from "zod";
+
+//#region src/db/attributes/get-default-model-name.ts
+const initGetDefaultModelName = ({ usePlural, schema }) => {
+	/**
+	* This function helps us get the default model name from the schema defined by devs.
+	* Often times, the user will be using the `modelName` which could had been customized by the users.
+	* This function helps us get the actual model name useful to match against the schema. (eg: schema[model])
+	*
+	* If it's still unclear what this does:
+	*
+	* 1. User can define a custom modelName.
+	* 2. When using a custom modelName, doing something like `schema[model]` will not work.
+	* 3. Using this function helps us get the actual model name based on the user's defined custom modelName.
+	*/
+	const getDefaultModelName = (model) => {
+		if (usePlural && model.charAt(model.length - 1) === "s") {
+			let pluralessModel = model.slice(0, -1);
+			let m$1 = schema[pluralessModel] ? pluralessModel : void 0;
+			if (!m$1) m$1 = Object.entries(schema).find(([_, f]) => f.modelName === pluralessModel)?.[0];
+			if (m$1) return m$1;
+		}
+		let m = schema[model] ? model : void 0;
+		if (!m) m = Object.entries(schema).find(([_, f]) => f.modelName === model)?.[0];
+		if (!m) throw new PecuniaError(`Model "${model}" not found in schema`);
+		return m;
+	};
+	return getDefaultModelName;
+};
+
+//#endregion
+//#region src/db/attributes/get-default-field-name.ts
+const initGetDefaultFieldName = ({ schema, usePlural }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	/**
+	* This function helps us get the default field name from the schema defined by devs.
+	* Often times, the user will be using the `fieldName` which could had been customized by the users.
+	* This function helps us get the actual field name useful to match against the schema. (eg: schema[model].fields[field])
+	*
+	* If it's still unclear what this does:
+	*
+	* 1. User can define a custom fieldName.
+	* 2. When using a custom fieldName, doing something like `schema[model].fields[field]` will not work.
+	*/
+	const getDefaultFieldName = ({ field, model: unsafeModel }) => {
+		if (field === "id" || field === "_id") return "id";
+		const model = getDefaultModelName(unsafeModel);
+		let f = schema[model]?.fields[field];
+		if (!f) {
+			const result = Object.entries(schema[model].fields).find(([_, f$1]) => f$1.fieldName === field);
+			if (result) {
+				f = result[1];
+				field = result[0];
+			}
+		}
+		if (!f) throw new PecuniaError(`Field ${field} not found in model ${model}`);
+		return field;
+	};
+	return getDefaultFieldName;
+};
+
+//#endregion
+//#region src/db/attributes/get-id-field.ts
+const initGetIdField = () => {
+	const idField = () => {
+		return {
+			type: "string",
+			required: true,
+			defaultValue: () => generateId(),
+			transform: {
+				input: (value) => {
+					if (!value) return void 0;
+					return value;
+				},
+				output: (value) => {
+					if (!value) return void 0;
+					return String(value);
+				}
+			}
+		};
+	};
+	return idField;
+};
+
+//#endregion
+//#region src/db/attributes/get-field-attributes.ts
+const initGetFieldAttributes = ({ usePlural, schema }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		usePlural,
+		schema
+	});
+	const getDefaultFieldName = initGetDefaultFieldName({
+		usePlural,
+		schema
+	});
+	const idField = initGetIdField();
+	const getFieldAttributes = ({ model, field }) => {
+		const defaultModelName = getDefaultModelName(model);
+		const defaultFieldName = getDefaultFieldName({
+			field,
+			model: defaultModelName
+		});
+		const fields = schema[defaultModelName].fields;
+		fields.id = idField();
+		const fieldAttributes = fields[defaultFieldName];
+		if (!fieldAttributes) throw new PecuniaError(`Field ${field} not found in model ${model}`);
+		return fieldAttributes;
+	};
+	return getFieldAttributes;
+};
+
+//#endregion
+//#region src/db/attributes/get-model-name.ts
+const initGetModelName = ({ usePlural, schema }) => {
+	const getDefaultModelName = initGetDefaultModelName({
+		schema,
+		usePlural
+	});
+	/**
+	* Users can overwrite the default model of some tables. This function helps find the correct model name.
+	* Furthermore, if the user passes `usePlural` as true in their adapter config,
+	* then we should return the model name ending with an `s`.
+	*/
+	const getModelName = (model) => {
+		const defaultModelKey = getDefaultModelName(model);
+		if (schema && schema[defaultModelKey] && schema[defaultModelKey].modelName !== model) return usePlural ? `${schema[defaultModelKey].modelName}s` : schema[defaultModelKey].modelName;
+		return usePlural ? `${model}s` : model;
+	};
+	return getModelName;
+};
+
+//#endregion
+//#region src/db/utils/with-apply-default.ts
+function withApplyDefault(value, field, action) {
+	if (action === "update") {
+		if (value === void 0 && field.onUpdate !== void 0) {
+			if (typeof field.onUpdate === "function") return field.onUpdate();
+			return field.onUpdate;
+		}
+		return value;
+	}
+	if (action === "create") {
+		if (value === void 0 || field.required === true && value === null) {
+			if (field.defaultValue !== void 0) {
+				if (typeof field.defaultValue === "function") return field.defaultValue();
+				return field.defaultValue;
+			}
+		}
+	}
+	return value;
+}
+function isObject(item) {
+	return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+function deepmerge(target, source) {
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	else if (isObject(target) && isObject(source)) {
+		const result = { ...target };
+		for (const [key, value] of Object.entries(source)) {
+			if (value === void 0) continue;
+			if (key in target) result[key] = deepmerge(target[key], value);
+			else result[key] = value;
+		}
+		return result;
+	}
+	return source;
+}
+
+//#endregion
+//#region src/db/get-payment-tables.ts
+const getPaymentTables = (options) => {
+	const { customer, idempotency_key, payment_method, product, price, usageRecord, subscription, subscriptionItem, subscriptionSchedule, invoice, invoiceItem, webHookEndpoint, webHookDelivery, event, sessionEvent, checkoutSession, paymentIntent, transaction, scheduledTask, auditLog, ...pluginTables } = (options.plugins ?? []).reduce((acc, plugin) => {
+		const schema = plugin.schema;
+		if (!schema) return acc;
+		for (const [key, value] of Object.entries(schema)) acc[key] = {
+			fields: {
+				...acc[key]?.fields,
+				...value.fields
+			},
+			modelName: value.modelName || key
+		};
+		return acc;
+	}, {});
+	return {
+		customer: {
+			modelName: "customer",
+			fields: {
+				id: {
+					type: "string",
+					required: true,
+					fieldName: "id",
+					unique: true,
+					sortable: true
+				},
+				phoneNumber: {
+					type: "string",
+					required: true,
+					fieldName: "phoneNumber",
+					sortable: true
+				},
+				firstName: {
+					type: "string",
+					required: true,
+					fieldName: "firstName",
+					sortable: true
+				},
+				lastName: {
+					type: "string",
+					required: true,
+					fieldName: "lastName",
+					sortable: true
+				},
+				email: {
+					type: "string",
+					required: true,
+					fieldName: "email",
+					sortable: true,
+					unique: true
+				},
+				paymentMethodId: {
+					type: "uuid",
+					required: false,
+					fieldName: "paymentMethodId",
+					references: {
+						model: "payment_methods",
+						field: "id",
+						onDelete: "set null"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				createdAt: {
+					type: "date",
+					required: true,
+					fieldName: "createdAt",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					sortable: true,
+					input: false,
+					returned: true,
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					required: true,
+					fieldName: "updatedAt",
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					sortable: true,
+					input: false,
+					returned: true,
+					validator: { output: z.date() }
+				},
+				...customer?.fields
+			},
+			relations: {
+				paymentMethods: {
+					kind: "many",
+					model: "payment_methods",
+					foreignKey: "customerId"
+				},
+				paymentIntents: {
+					kind: "many",
+					model: "payment_intent",
+					foreignKey: "customerId"
+				},
+				subscriptions: {
+					kind: "many",
+					model: "subscription",
+					foreignKey: "customerId"
+				},
+				invoices: {
+					kind: "many",
+					model: "invoice",
+					foreignKey: "customerId"
+				},
+				transactions: {
+					kind: "many",
+					model: "transactions",
+					foreignKey: "customerId"
+				},
+				defaultPaymentMethod: {
+					kind: "one",
+					model: "payment_methods",
+					foreignKey: "paymentMethodId"
+				}
+			},
+			order: 1
+		},
+		idempotency_key: {
+			modelName: "idempotency_key",
+			order: 10,
+			fields: {
+				id: {
+					type: "string",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				key: {
+					type: "string",
+					fieldName: "key",
+					required: false,
+					unique: true,
+					sortable: true,
+					validator: { input: z.string().max(255).optional() }
+				},
+				requestPath: {
+					fieldName: "request_path",
+					type: "string",
+					required: false,
+					sortable: true,
+					validator: { input: z.string().max(150).optional() }
+				},
+				requestMethod: {
+					type: "string",
+					fieldName: "request_method",
+					required: false,
+					sortable: true,
+					validator: { input: z.string().max(10).optional() }
+				},
+				requestBody: {
+					type: "string",
+					fieldName: "request_body",
+					required: false,
+					validator: { input: z.unknown().optional() }
+				},
+				responseStatus: {
+					type: "string",
+					fieldName: "response_status",
+					required: false,
+					validator: { output: z.number().int().optional() }
+				},
+				responseBody: {
+					type: "string",
+					fieldName: "response_body",
+					required: false,
+					validator: { input: z.unknown().optional() }
+				},
+				objectType: {
+					type: "string",
+					fieldName: "object_type",
+					required: false,
+					sortable: true,
+					validator: { input: z.string().max(50).optional() }
+				},
+				objectId: {
+					type: "string",
+					fieldName: "object_id",
+					required: false,
+					sortable: true,
+					validator: { input: z.string().max(255).optional() }
+				},
+				expiresAt: {
+					type: "string",
+					fieldName: "expires_at",
+					required: false,
+					validator: { input: z.date().optional() }
+				},
+				createdAt: {
+					type: "string",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: {
+				unique: [{
+					name: "idempotency_key_object_unique",
+					fields: ["objectType", "objectId"]
+				}],
+				indexes: [{
+					name: "idempotency_key_idx",
+					unique: true,
+					fields: ["key"]
+				}, {
+					name: "expires_at_idx",
+					fields: ["expiresAt"]
+				}]
+			}
+		},
+		payment_method: {
+			modelName: "payment_methods",
+			order: 2,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				phone: {
+					type: "string",
+					fieldName: "phone_number",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(15),
+						output: z.string()
+					}
+				},
+				provider: {
+					type: "string",
+					fieldName: "payment_providers",
+					required: true,
+					sortable: true,
+					defaultValue: PaymentProviders.MPESA,
+					validator: {
+						input: z.enum(PaymentProviders),
+						output: z.enum(PaymentProviders)
+					}
+				},
+				isActive: {
+					type: "boolean",
+					fieldName: "is_active",
+					required: false,
+					defaultValue: true,
+					validator: {
+						input: z.boolean().optional(),
+						output: z.boolean()
+					}
+				},
+				customerId: {
+					type: "uuid",
+					fieldName: "customer_id",
+					required: true,
+					index: true,
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					references: {
+						model: "customer",
+						field: "id",
+						onDelete: "cascade"
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: {
+				unique: [{
+					name: "payment_methods_customer_phone_provider_unique",
+					fields: [
+						"customerId",
+						"phone",
+						"provider"
+					]
+				}],
+				indexes: [{
+					name: "payment_methods_customer_active_idx",
+					fields: ["customerId", "isActive"]
+				}]
+			},
+			relations: {
+				customer: {
+					kind: "one",
+					model: "customer",
+					foreignKey: "customerId"
+				},
+				subscriptions: {
+					kind: "many",
+					model: "subscription",
+					foreignKey: "paymentMethodId"
+				}
+			}
+		},
+		product: {
+			modelName: "products",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				type: {
+					type: "string",
+					fieldName: "product_type",
+					required: false
+				},
+				name: {
+					type: "string",
+					fieldName: "product_name",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255),
+						output: z.string()
+					},
+					index: true
+				},
+				description: {
+					type: "string",
+					fieldName: "product_description",
+					required: false
+				},
+				images: {
+					type: "string[]",
+					fieldName: "product_images",
+					required: true,
+					defaultValue: () => [],
+					validator: {
+						input: z.array(z.string()).default([]),
+						output: z.array(z.string())
+					}
+				},
+				defaultPriceId: {
+					type: "uuid",
+					fieldName: "default_price_id",
+					required: false,
+					references: {
+						model: "prices",
+						field: "id",
+						onDelete: "set null"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				marketingFeatures: {
+					type: "json",
+					fieldName: "marketing_features",
+					required: false,
+					validator: {
+						input: z.array(z.object({ name: z.string() })).optional(),
+						output: z.array(z.object({ name: z.string() })).optional()
+					}
+				},
+				packageDimensions: {
+					type: "json",
+					fieldName: "package_dimensions",
+					required: false,
+					validator: {
+						input: z.object({
+							height: z.number(),
+							length: z.number(),
+							weight: z.number(),
+							width: z.number()
+						}).optional(),
+						output: z.object({
+							height: z.number(),
+							length: z.number(),
+							weight: z.number(),
+							width: z.number()
+						}).optional()
+					}
+				},
+				shippable: {
+					type: "boolean",
+					fieldName: "shippable",
+					required: false
+				},
+				url: {
+					type: "string",
+					fieldName: "url",
+					required: false
+				},
+				active: {
+					type: "boolean",
+					fieldName: "active",
+					required: false,
+					defaultValue: true
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false
+				},
+				deleted: {
+					type: "boolean",
+					fieldName: "deleted",
+					required: true,
+					defaultValue: false,
+					input: false,
+					returned: true
+				},
+				deletedAt: {
+					type: "date",
+					fieldName: "deleted_at",
+					required: false,
+					input: false,
+					returned: true
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date()
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date()
+				}
+			},
+			constraints: { indexes: [{
+				name: "product_name_idx",
+				fields: ["name"]
+			}] },
+			relations: {
+				prices: {
+					kind: "many",
+					model: "prices",
+					foreignKey: "productId"
+				},
+				defaultPrice: {
+					kind: "one",
+					model: "prices",
+					foreignKey: "defaultPriceId"
+				}
+			}
+		},
+		price: {
+			modelName: "prices",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				productId: {
+					type: "uuid",
+					fieldName: "product_id",
+					required: false,
+					references: {
+						model: "products",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				unitAmount: {
+					type: "number",
+					fieldName: "unit_amount",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				currency: {
+					type: "string",
+					fieldName: "currency",
+					required: false,
+					defaultValue: Currency.KES,
+					validator: {
+						input: z.enum(Currency).optional(),
+						output: z.enum(Currency)
+					},
+					sortable: true
+				},
+				type: {
+					type: "string",
+					fieldName: "price_type",
+					required: false,
+					defaultValue: PriceType.ONE_TIME,
+					validator: {
+						input: z.enum(PriceType).optional(),
+						output: z.enum(PriceType)
+					},
+					sortable: true
+				},
+				pricingModel: {
+					type: "string",
+					fieldName: "pricing_model",
+					required: false,
+					defaultValue: PricingModel.FLAT,
+					validator: {
+						input: z.enum(PricingModel).optional(),
+						output: z.enum(PricingModel)
+					},
+					sortable: true
+				},
+				billingInterval: {
+					type: "string",
+					fieldName: "billing_interval",
+					required: false,
+					defaultValue: BillingInterval.MONTH,
+					validator: {
+						input: z.enum(BillingInterval).optional(),
+						output: z.enum(BillingInterval)
+					},
+					sortable: true
+				},
+				billingIntervalCount: {
+					type: "number",
+					fieldName: "billing_interval_count",
+					required: false,
+					defaultValue: 1,
+					validator: {
+						input: z.number().int().min(1).optional(),
+						output: z.number().int()
+					}
+				},
+				trialPeriodDays: {
+					type: "number",
+					fieldName: "trial_period_days",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				usageAggregation: {
+					type: "string",
+					fieldName: "usage_aggregation",
+					required: false,
+					validator: {
+						input: z.string().optional(),
+						output: z.string().optional()
+					},
+					sortable: true
+				},
+				active: {
+					type: "boolean",
+					fieldName: "active",
+					required: false,
+					defaultValue: true,
+					validator: {
+						input: z.boolean().optional(),
+						output: z.boolean()
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				deleted: {
+					type: "boolean",
+					fieldName: "deleted",
+					required: true,
+					defaultValue: false,
+					input: false,
+					returned: true,
+					validator: { output: z.boolean() },
+					index: true
+				},
+				deletedAt: {
+					type: "date",
+					fieldName: "deleted_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "price_product_active_idx",
+					fields: ["productId", "active"]
+				},
+				{
+					name: "price_type_active_idx",
+					fields: ["type", "active"]
+				},
+				{
+					name: "price_deleted_idx",
+					fields: ["deleted"]
+				}
+			] },
+			checks: [{
+				name: "billing_interval_countx",
+				kind: "gt",
+				field: "billingIntervalCount",
+				value: 0
+			}],
+			relations: {
+				product: {
+					kind: "one",
+					model: "products",
+					foreignKey: "productId"
+				},
+				subscriptionItems: {
+					kind: "many",
+					model: "subscription_item",
+					foreignKey: "priceId"
+				},
+				invoiceItems: {
+					kind: "many",
+					model: "invoice_item",
+					foreignKey: "priceId"
+				}
+			}
+		},
+		usageRecord: {
+			modelName: "usage_record",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				subscriptionItemId: {
+					type: "uuid",
+					fieldName: "subscription_item_id",
+					required: false,
+					references: {
+						model: "subscription_item",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				quantity: {
+					type: "number",
+					fieldName: "quantity",
+					required: true,
+					validator: {
+						input: z.number().int(),
+						output: z.number().int()
+					}
+				},
+				timestamp: {
+					type: "date",
+					fieldName: "timestamp",
+					required: false,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				},
+				action: {
+					type: "string",
+					fieldName: "usage_action",
+					required: false,
+					defaultValue: UsageAction.INCREMENT,
+					sortable: true,
+					validator: {
+						input: z.enum(UsageAction).optional(),
+						output: z.enum(UsageAction)
+					}
+				},
+				idempotencyKey: {
+					type: "string",
+					fieldName: "idempotency_key",
+					required: false,
+					unique: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255).optional(),
+						output: z.string().max(255).optional()
+					},
+					index: true
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [{
+				name: "usage_record_subscription_item_id_timestamp_idx",
+				fields: ["subscriptionItemId", "timestamp"]
+			}, {
+				name: "usage_record_timestamp_idx",
+				fields: ["timestamp"]
+			}] },
+			relations: { subscriptionItem: {
+				kind: "one",
+				model: "subscription_item",
+				foreignKey: "subscriptionItemId"
+			} }
+		},
+		subscription: {
+			modelName: "subscription",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				customerId: {
+					type: "uuid",
+					fieldName: "customer_id",
+					required: true,
+					references: {
+						model: "customer",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				paymentMethodId: {
+					type: "uuid",
+					fieldName: "payment_method_id",
+					required: false,
+					references: {
+						model: "payment_methods",
+						field: "id",
+						onDelete: "set null"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				status: {
+					type: "string",
+					fieldName: "subscription_status",
+					required: false,
+					defaultValue: SubscriptionStatus.INCOMPLETE,
+					sortable: true,
+					validator: {
+						input: z.enum(SubscriptionStatus).optional(),
+						output: z.enum(SubscriptionStatus)
+					},
+					index: true
+				},
+				currentBillingPeriodStart: {
+					type: "date",
+					fieldName: "current_billing_period_start",
+					required: true,
+					validator: {
+						input: z.date(),
+						output: z.date()
+					}
+				},
+				currentBillingPeriodEnd: {
+					type: "date",
+					fieldName: "current_billing_period_end",
+					required: true,
+					validator: {
+						input: z.date(),
+						output: z.date()
+					},
+					index: true
+				},
+				currentTrialStart: {
+					type: "date",
+					fieldName: "current_trial_start",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				currentTrialEnd: {
+					type: "date",
+					fieldName: "current_trial_end",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					},
+					index: true
+				},
+				cancelAtPeriodEnd: {
+					type: "boolean",
+					fieldName: "cancel_at_period_end",
+					required: true,
+					defaultValue: false,
+					validator: {
+						input: z.boolean().optional(),
+						output: z.boolean()
+					}
+				},
+				canceledAt: {
+					type: "date",
+					fieldName: "canceled_at",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				cancelAt: {
+					type: "date",
+					fieldName: "cancel_at",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				daysUntilDue: {
+					type: "number",
+					fieldName: "days_until_due",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				proration: {
+					type: "string",
+					fieldName: "proration",
+					required: true,
+					defaultValue: ProrationBehavior.CREATE_PRORATIONS,
+					sortable: true,
+					validator: {
+						input: z.enum(ProrationBehavior).optional(),
+						output: z.enum(ProrationBehavior)
+					}
+				},
+				collectionMethod: {
+					type: "string",
+					fieldName: "collection_method",
+					required: true,
+					defaultValue: CollectionMethod.SEND_INVOICE,
+					sortable: true,
+					validator: {
+						input: z.enum(CollectionMethod).optional(),
+						output: z.enum(CollectionMethod)
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				deleted: {
+					type: "boolean",
+					fieldName: "deleted",
+					required: true,
+					defaultValue: false,
+					input: false,
+					returned: true,
+					validator: { output: z.boolean() },
+					index: true
+				},
+				deletedAt: {
+					type: "date",
+					fieldName: "deleted_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				subscriptionStartedAt: {
+					type: "date",
+					fieldName: "subscription_started_at",
+					required: true,
+					validator: {
+						input: z.date(),
+						output: z.date()
+					}
+				},
+				subscriptionEndedAt: {
+					type: "date",
+					fieldName: "subscription_ended_at",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "subscription_customer_id_status_idx",
+					fields: ["customerId", "status"]
+				},
+				{
+					name: "subscription_current_billing_period_end_status_idx",
+					fields: ["currentBillingPeriodEnd", "status"]
+				},
+				{
+					name: "subscription_current_trial_end_status_idx",
+					fields: ["currentTrialEnd", "status"]
+				},
+				{
+					name: "subscription_payment_method_id_idx",
+					fields: ["paymentMethodId"]
+				},
+				{
+					name: "subscription_deleted_idx",
+					fields: ["deleted"]
+				}
+			] },
+			checks: [{
+				name: "days_until_due_gte_0",
+				kind: "gte",
+				field: "daysUntilDue",
+				value: 0
+			}],
+			relations: {
+				items: {
+					kind: "many",
+					model: "subscription_item",
+					foreignKey: "subscriptionId"
+				},
+				invoices: {
+					kind: "many",
+					model: "invoice",
+					foreignKey: "subscriptionId"
+				},
+				paymentIntents: {
+					kind: "many",
+					model: "payment_intent",
+					foreignKey: "subscriptionId"
+				},
+				schedules: {
+					kind: "many",
+					model: "subscription_schedule",
+					foreignKey: "subscriptionId"
+				},
+				checkoutSession: {
+					kind: "one",
+					model: "checkout_sessions",
+					foreignKey: "id"
+				},
+				customer: {
+					kind: "one",
+					model: "customer",
+					foreignKey: "customerId"
+				},
+				paymentMethod: {
+					kind: "one",
+					model: "payment_methods",
+					foreignKey: "paymentMethodId"
+				}
+			}
+		},
+		subscriptionItem: {
+			modelName: "subscription_item",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				subscriptionId: {
+					type: "uuid",
+					fieldName: "subscription_id",
+					required: false,
+					references: {
+						model: "subscription",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				priceId: {
+					type: "uuid",
+					fieldName: "price_id",
+					required: true,
+					references: {
+						model: "prices",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				quantity: {
+					type: "number",
+					fieldName: "quantity",
+					required: false,
+					defaultValue: 1,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				deleted: {
+					type: "boolean",
+					fieldName: "deleted",
+					required: true,
+					defaultValue: false,
+					input: false,
+					returned: true,
+					validator: { output: z.boolean() },
+					index: true
+				},
+				deletedAt: {
+					type: "date",
+					fieldName: "deleted_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: {
+				unique: [{
+					name: "subscription_item_subscription_price_deleted_unique",
+					fields: [
+						"subscriptionId",
+						"priceId",
+						"deleted"
+					]
+				}],
+				indexes: [
+					{
+						name: "subscription_item_subscription_id_idx",
+						fields: ["subscriptionId"]
+					},
+					{
+						name: "subscription_item_price_id_idx",
+						fields: ["priceId"]
+					},
+					{
+						name: "subscription_item_deleted_idx",
+						fields: ["deleted"]
+					}
+				]
+			},
+			relations: {
+				usageRecords: {
+					kind: "many",
+					model: "usage_record",
+					foreignKey: "subscriptionItemId"
+				},
+				subscription: {
+					kind: "one",
+					model: "subscription",
+					foreignKey: "subscriptionId"
+				},
+				price: {
+					kind: "one",
+					model: "prices",
+					foreignKey: "priceId"
+				}
+			}
+		},
+		subscriptionSchedule: {
+			modelName: "subscription_schedule",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				subscriptionId: {
+					type: "uuid",
+					fieldName: "subscription_id",
+					required: true,
+					references: {
+						model: "subscription",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				phases: {
+					type: "json",
+					fieldName: "phases",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				status: {
+					type: "string",
+					fieldName: "schedule_status",
+					required: true,
+					defaultValue: ScheduleStatus.ACTIVE,
+					sortable: true,
+					validator: {
+						input: z.enum(ScheduleStatus).optional(),
+						output: z.enum(ScheduleStatus)
+					},
+					index: true
+				},
+				startDate: {
+					type: "date",
+					fieldName: "start_date",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					},
+					index: true
+				},
+				endDate: {
+					type: "date",
+					fieldName: "end_date",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				completedAt: {
+					type: "date",
+					fieldName: "completed_at",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				releasedAt: {
+					type: "date",
+					fieldName: "released_at",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "subscription_schedule_subscription_id_status_idx",
+					fields: ["subscriptionId", "status"]
+				},
+				{
+					name: "subscription_schedule_start_date_idx",
+					fields: ["startDate"]
+				},
+				{
+					name: "subscription_schedule_status_idx",
+					fields: ["status"]
+				}
+			] },
+			relations: { subscription: {
+				kind: "one",
+				model: "subscription",
+				foreignKey: "subscriptionId"
+			} }
+		},
+		invoice: {
+			modelName: "invoice",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				customerId: {
+					type: "uuid",
+					fieldName: "customer_id",
+					required: false,
+					references: {
+						model: "customer",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				subscriptionId: {
+					type: "uuid",
+					fieldName: "subscription_id",
+					required: false,
+					references: {
+						model: "subscription",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				status: {
+					type: "string",
+					fieldName: "invoice_status",
+					required: true,
+					defaultValue: InvoiceStatus.DRAFT,
+					sortable: true,
+					validator: {
+						input: z.enum(InvoiceStatus).optional(),
+						output: z.enum(InvoiceStatus)
+					},
+					index: true
+				},
+				subtotal: {
+					type: "number",
+					fieldName: "sub_total",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				total: {
+					type: "number",
+					fieldName: "total",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				amountPaid: {
+					type: "number",
+					fieldName: "amount_paid",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				amountDue: {
+					type: "number",
+					fieldName: "amount_due",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				amountRemaining: {
+					type: "number",
+					fieldName: "amount_remaining",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				currency: {
+					type: "string",
+					fieldName: "currency",
+					required: true,
+					defaultValue: Currency.KES,
+					sortable: true,
+					validator: {
+						input: z.nativeEnum(Currency).optional(),
+						output: z.nativeEnum(Currency)
+					}
+				},
+				invoiceBillingPeriodStart: {
+					type: "date",
+					fieldName: "invoice_billing_period_start",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				invoiceBillingPeriodEnd: {
+					type: "date",
+					fieldName: "invoice_billing_period_end",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				invoiceDueDate: {
+					type: "date",
+					fieldName: "invoice_due_date",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					},
+					index: true
+				},
+				collectionMethod: {
+					type: "string",
+					fieldName: "invoice_collection_method",
+					required: true,
+					defaultValue: CollectionMethod.SEND_INVOICE,
+					sortable: true,
+					validator: {
+						input: z.enum(CollectionMethod).optional(),
+						output: z.enum(CollectionMethod)
+					}
+				},
+				invoiceNumber: {
+					type: "string",
+					fieldName: "invoice_number",
+					required: true,
+					unique: true,
+					sortable: true,
+					validator: {
+						input: z.string(),
+						output: z.string()
+					},
+					index: true
+				},
+				customerName: {
+					type: "string",
+					fieldName: "customer_name",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255),
+						output: z.string()
+					}
+				},
+				customerEmail: {
+					type: "string",
+					fieldName: "customer_email",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().email().max(255),
+						output: z.string()
+					},
+					index: true
+				},
+				customerPhoneNumber: {
+					type: "string",
+					fieldName: "customer_phone_number",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(15),
+						output: z.string()
+					},
+					index: true
+				},
+				autoAdvance: {
+					type: "boolean",
+					fieldName: "invoice_auto_advance",
+					required: false,
+					defaultValue: true,
+					validator: {
+						input: z.boolean().optional(),
+						output: z.boolean()
+					}
+				},
+				attemptCount: {
+					type: "number",
+					fieldName: "invoice_attempt_count",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				nextPaymentAttempt: {
+					type: "date",
+					fieldName: "next_payment_attempt",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					},
+					index: true
+				},
+				description: {
+					type: "string",
+					fieldName: "invoice_description",
+					required: false
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				deleted: {
+					type: "boolean",
+					fieldName: "deleted",
+					required: true,
+					defaultValue: false,
+					input: false,
+					returned: true,
+					validator: { output: z.boolean() },
+					index: true
+				},
+				deletedAt: {
+					type: "date",
+					fieldName: "deleted_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				finalizedAt: {
+					type: "date",
+					fieldName: "finalized_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				paidAt: {
+					type: "date",
+					fieldName: "paid_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				voidedAt: {
+					type: "date",
+					fieldName: "voided_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				markedUncollectibleAt: {
+					type: "date",
+					fieldName: "marked_uncollectible_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "invoice_customer_id_status_idx",
+					fields: ["customerId", "status"]
+				},
+				{
+					name: "invoice_subscription_id_idx",
+					fields: ["subscriptionId"]
+				},
+				{
+					name: "invoice_status_due_date_idx",
+					fields: ["status", "invoiceDueDate"]
+				},
+				{
+					name: "invoice_status_next_payment_attempt_idx",
+					fields: ["status", "nextPaymentAttempt"]
+				},
+				{
+					name: "invoice_customer_phone_number_idx",
+					fields: ["customerPhoneNumber"]
+				},
+				{
+					name: "invoice_deleted_idx",
+					fields: ["deleted"]
+				}
+			] },
+			checks: [
+				{
+					name: "invoice_subtotal_gte_0",
+					kind: "gte",
+					field: "subtotal",
+					value: 0
+				},
+				{
+					name: "invoice_total_gte_0",
+					kind: "gte",
+					field: "total",
+					value: 0
+				},
+				{
+					name: "invoice_amount_paid_gte_0",
+					kind: "gte",
+					field: "amountPaid",
+					value: 0
+				},
+				{
+					name: "invoice_amount_due_gte_0",
+					kind: "gte",
+					field: "amountDue",
+					value: 0
+				},
+				{
+					name: "invoice_attempt_count_gte_0",
+					kind: "gte",
+					field: "attemptCount",
+					value: 0
+				}
+			],
+			relations: {
+				invoiceItems: {
+					kind: "many",
+					model: "invoice_item",
+					foreignKey: "invoiceId"
+				},
+				paymentIntents: {
+					kind: "many",
+					model: "payment_intent",
+					foreignKey: "invoiceId"
+				},
+				customer: {
+					kind: "one",
+					model: "customer",
+					foreignKey: "customerId"
+				},
+				subscription: {
+					kind: "one",
+					model: "subscription",
+					foreignKey: "subscriptionId"
+				}
+			}
+		},
+		invoiceItem: {
+			modelName: "invoice_item",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				invoiceId: {
+					type: "uuid",
+					fieldName: "invoice_id",
+					required: true,
+					references: {
+						model: "invoice",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				priceId: {
+					type: "uuid",
+					fieldName: "price_id",
+					required: false,
+					references: {
+						model: "prices",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				description: {
+					type: "string",
+					fieldName: "invoice_item_description",
+					required: false
+				},
+				quantity: {
+					type: "number",
+					fieldName: "invoice_item_quantity",
+					required: false,
+					defaultValue: 1,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				unitAmount: {
+					type: "number",
+					fieldName: "invoice_item_unit_amount",
+					required: true,
+					defaultValue: 1,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				amount: {
+					type: "number",
+					fieldName: "invoice_item_amount",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				currency: {
+					type: "string",
+					fieldName: "invoice_item_currency",
+					required: false,
+					defaultValue: Currency.KES,
+					sortable: true,
+					validator: {
+						input: z.enum(Currency).optional(),
+						output: z.enum(Currency).optional()
+					}
+				},
+				invoicePeriodStart: {
+					type: "date",
+					fieldName: "invoice_period_start",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				invoicePeriodEnd: {
+					type: "date",
+					fieldName: "invoice_period_end",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					}
+				},
+				invoiceProration: {
+					type: "boolean",
+					fieldName: "invoice_proration",
+					required: false,
+					defaultValue: false,
+					validator: {
+						input: z.boolean().optional(),
+						output: z.boolean().optional()
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [{
+				name: "invoice_item_invoice_id_idx",
+				fields: ["invoiceId"]
+			}, {
+				name: "invoice_item_price_id_idx",
+				fields: ["priceId"]
+			}] },
+			checks: [
+				{
+					name: "invoice_item_unit_amount_gte_0",
+					kind: "gte",
+					field: "unitAmount",
+					value: 0
+				},
+				{
+					name: "invoice_item_amount_gte_0",
+					kind: "gte",
+					field: "amount",
+					value: 0
+				},
+				{
+					name: "invoice_item_quantity_gte_0",
+					kind: "gte",
+					field: "quantity",
+					value: 0
+				}
+			],
+			relations: {
+				invoice: {
+					kind: "one",
+					model: "invoice",
+					foreignKey: "invoiceId"
+				},
+				price: {
+					kind: "one",
+					model: "prices",
+					foreignKey: "priceId"
+				}
+			}
+		},
+		webHookEndpoint: {
+			modelName: "webhook_endpoints",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				url: {
+					type: "string",
+					fieldName: "endpoint_url",
+					required: true,
+					unique: true,
+					sortable: false,
+					validator: {
+						input: z.string().url(),
+						output: z.string()
+					},
+					index: true
+				},
+				description: {
+					type: "string",
+					fieldName: "description",
+					required: false
+				},
+				enabledEvents: {
+					type: "string[]",
+					fieldName: "enabled_webhook_events",
+					required: false,
+					defaultValue: () => [],
+					validator: {
+						input: z.array(z.string()).default([]),
+						output: z.array(z.string())
+					}
+				},
+				active: {
+					type: "boolean",
+					fieldName: "is_webhook_active",
+					required: false,
+					defaultValue: true,
+					validator: {
+						input: z.boolean().optional(),
+						output: z.boolean()
+					}
+				},
+				secret: {
+					type: "string",
+					fieldName: "webhook_secret_signature",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255),
+						output: z.string()
+					},
+					returned: false
+				},
+				apiVersion: {
+					type: "string",
+					fieldName: "webhook_api_version",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(10).optional(),
+						output: z.string().max(10).optional()
+					}
+				},
+				deleted: {
+					type: "boolean",
+					fieldName: "deleted",
+					required: true,
+					defaultValue: false,
+					input: false,
+					returned: true,
+					validator: { output: z.boolean() },
+					index: true
+				},
+				deletedAt: {
+					type: "date",
+					fieldName: "deleted_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [{
+				name: "webhook_endpoints_active_deleted_idx",
+				fields: ["active", "deleted"]
+			}, {
+				name: "webhook_endpoint_unique_url",
+				unique: true,
+				fields: ["url"]
+			}] },
+			relations: { webhookDeliveries: {
+				kind: "many",
+				model: "webhook_delivery",
+				foreignKey: "endpointId"
+			} }
+		},
+		webHookDelivery: {
+			modelName: "webhook_delivery",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				endpointId: {
+					type: "uuid",
+					fieldName: "endpoint_id",
+					required: true,
+					references: {
+						model: "webhook_endpoints",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				eventId: {
+					type: "uuid",
+					fieldName: "event_id",
+					required: true,
+					references: {
+						model: "events",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				url: {
+					type: "string",
+					fieldName: "webhook_delivery_url",
+					required: true,
+					validator: {
+						input: z.string().url(),
+						output: z.string()
+					}
+				},
+				payload: {
+					type: "json",
+					fieldName: "payload",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				headers: {
+					type: "json",
+					fieldName: "headers",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				statusCode: {
+					type: "number",
+					fieldName: "status_code",
+					required: false,
+					validator: {
+						input: z.number().int().optional(),
+						output: z.number().int().optional()
+					}
+				},
+				responseBody: {
+					type: "string",
+					fieldName: "response_body",
+					required: false
+				},
+				responseTime: {
+					type: "number",
+					fieldName: "response_time",
+					required: false,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				error: {
+					type: "string",
+					fieldName: "error",
+					required: false
+				},
+				status: {
+					type: "string",
+					fieldName: "webhook_event_status",
+					required: true,
+					defaultValue: WebHookEventStatus.PENDING,
+					sortable: true,
+					validator: {
+						input: z.enum(WebHookEventStatus).optional(),
+						output: z.enum(WebHookEventStatus)
+					},
+					index: true
+				},
+				attemptNumber: {
+					type: "number",
+					fieldName: "webhook_attempts",
+					required: false,
+					defaultValue: 1,
+					validator: {
+						input: z.number().int().min(1).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				nextWebhookRetryAt: {
+					type: "date",
+					fieldName: "next_webhook_retry_at",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					},
+					index: true
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				deliveredAt: {
+					type: "date",
+					fieldName: "delivered_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				triggeredBy: {
+					type: "string",
+					fieldName: "webhook_delivery_trigger",
+					required: true,
+					defaultValue: WebHookDeliveryTrigger.SYSTEM,
+					sortable: true,
+					validator: {
+						input: z.enum(WebHookDeliveryTrigger).optional(),
+						output: z.enum(WebHookDeliveryTrigger)
+					}
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "webhook_delivery_endpoint_id_status_idx",
+					fields: ["endpointId", "status"]
+				},
+				{
+					name: "webhook_delivery_event_id_idx",
+					fields: ["eventId"]
+				},
+				{
+					name: "webhook_delivery_next_retry_at_status_idx",
+					fields: ["nextWebhookRetryAt", "status"]
+				}
+			] },
+			checks: [{
+				name: "webhook_delivery_attempt_number_gte_1",
+				kind: "gte",
+				field: "attemptNumber",
+				value: 1
+			}, {
+				name: "webhook_delivery_response_time_gte_0",
+				kind: "gte",
+				field: "responseTime",
+				value: 0
+			}],
+			relations: {
+				endpoint: {
+					kind: "one",
+					model: "webhook_endpoints",
+					foreignKey: "endpointId"
+				},
+				event: {
+					kind: "one",
+					model: "event",
+					foreignKey: "eventId"
+				}
+			}
+		},
+		event: {
+			modelName: "event",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				type: {
+					type: "string",
+					fieldName: "event_type",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(100),
+						output: z.string()
+					},
+					index: true
+				},
+				data: {
+					type: "json",
+					fieldName: "event_data",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				objectType: {
+					type: "string",
+					fieldName: "event_object_type",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(100).optional(),
+						output: z.string().max(100).optional()
+					},
+					index: true
+				},
+				objectId: {
+					type: "string",
+					fieldName: "event_object_id",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(255).optional(),
+						output: z.string().max(255).optional()
+					},
+					index: true
+				},
+				apiVersion: {
+					type: "string",
+					fieldName: "event_api_version",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(10),
+						output: z.string().max(10)
+					}
+				},
+				idempotencyKey: {
+					type: "string",
+					fieldName: "event_idempotency_key",
+					required: true,
+					unique: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255),
+						output: z.string().max(255)
+					},
+					index: true
+				},
+				deliveryCount: {
+					type: "number",
+					fieldName: "delivery_count",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				lastDeliveredAt: {
+					type: "date",
+					fieldName: "last_delivered_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				lastDeliveryStatus: {
+					type: "string",
+					fieldName: "last_delivery_status",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(50).optional(),
+						output: z.string().max(50).optional()
+					}
+				},
+				successfulDeliveries: {
+					type: "number",
+					fieldName: "successful_deliveries",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				failedDeliveries: {
+					type: "number",
+					fieldName: "failed_deliveries",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				requestId: {
+					type: "string",
+					fieldName: "event_request_id",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(255).optional(),
+						output: z.string().max(255).optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				},
+				payloadHash: {
+					type: "string",
+					fieldName: "payload_hash",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(64).optional(),
+						output: z.string().max(64).optional()
+					}
+				}
+			},
+			constraints: { indexes: [{
+				name: "event_created_at_type_idx",
+				fields: ["createdAt", "type"]
+			}, {
+				name: "event_object_id_object_type_idx",
+				fields: ["objectId", "objectType"]
+			}] },
+			checks: [
+				{
+					name: "event_delivery_count_gte_0",
+					kind: "gte",
+					field: "deliveryCount",
+					value: 0
+				},
+				{
+					name: "event_successful_deliveries_gte_0",
+					kind: "gte",
+					field: "successfulDeliveries",
+					value: 0
+				},
+				{
+					name: "event_failed_deliveries_gte_0",
+					kind: "gte",
+					field: "failedDeliveries",
+					value: 0
+				}
+			],
+			relations: {
+				webHookDeliveries: {
+					kind: "many",
+					model: "webhook_delivery",
+					foreignKey: "eventId"
+				},
+				sessionEvents: {
+					kind: "many",
+					model: "sessions",
+					foreignKey: "eventId"
+				}
+			}
+		},
+		sessionEvent: {
+			modelName: "sessions",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				sessionId: {
+					type: "uuid",
+					fieldName: "session_id",
+					required: true,
+					references: {
+						model: "checkout_sessions",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				eventId: {
+					type: "uuid",
+					fieldName: "event_id",
+					required: true,
+					references: {
+						model: "event",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				}
+			},
+			constraints: { indexes: [{
+				name: "sessions_session_id_created_at_idx",
+				fields: ["sessionId", "createdAt"]
+			}, {
+				name: "sessions_event_id_idx",
+				fields: ["eventId"]
+			}] },
+			relations: {
+				session: {
+					kind: "one",
+					model: "checkout_sessions",
+					foreignKey: "sessionId"
+				},
+				event: {
+					kind: "one",
+					model: "event",
+					foreignKey: "eventId"
+				}
+			}
+		},
+		checkoutSession: {
+			modelName: "checkout_sessions",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				expiresAt: {
+					type: "date",
+					fieldName: "checkout_session_expires_at",
+					required: true,
+					validator: {
+						input: z.date(),
+						output: z.date()
+					},
+					index: true
+				},
+				successUrl: {
+					type: "string",
+					fieldName: "success_url",
+					required: false,
+					validator: {
+						input: z.url().optional(),
+						output: z.url().optional()
+					}
+				},
+				cancelUrl: {
+					type: "string",
+					fieldName: "cancel_url",
+					required: false,
+					validator: {
+						input: z.url().optional(),
+						output: z.url().optional()
+					}
+				},
+				mode: {
+					type: "string",
+					fieldName: "checkout_session_mode",
+					required: true,
+					defaultValue: CheckoutSessionMode.PAYMENT,
+					sortable: true,
+					validator: {
+						input: z.enum(CheckoutSessionMode).optional(),
+						output: z.enum(CheckoutSessionMode)
+					}
+				},
+				customerId: {
+					type: "uuid",
+					fieldName: "customer_id",
+					required: true,
+					references: {
+						model: "customer",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				customerEmail: {
+					type: "string",
+					fieldName: "customer_email_address",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().email().max(255),
+						output: z.string()
+					}
+				},
+				paymentIntentId: {
+					type: "uuid",
+					fieldName: "payment_intent_id",
+					required: true,
+					references: {
+						model: "payment_intents",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				subscriptionId: {
+					type: "uuid",
+					fieldName: "subscription_id",
+					required: true,
+					references: {
+						model: "subscription",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				status: {
+					type: "string",
+					fieldName: "checkout_session_status",
+					required: true,
+					defaultValue: CheckoutSessionStatus.OPEN,
+					sortable: true,
+					validator: {
+						input: z.enum(CheckoutSessionStatus).optional(),
+						output: z.enum(CheckoutSessionStatus)
+					},
+					index: true
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				completedAt: {
+					type: "date",
+					fieldName: "completed_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				}
+			},
+			constraints: { indexes: [{
+				name: "checkout_sessions_expires_at_idx",
+				fields: ["expiresAt"]
+			}, {
+				name: "checkout_sessions_status_created_at_idx",
+				fields: ["status", "createdAt"]
+			}] },
+			relations: {
+				events: {
+					kind: "many",
+					model: "sessions",
+					foreignKey: "sessionId"
+				},
+				customer: {
+					kind: "one",
+					model: "customer",
+					foreignKey: "customerId"
+				},
+				paymentIntent: {
+					kind: "one",
+					model: "payment_intent",
+					foreignKey: "paymentIntentId"
+				},
+				subscription: {
+					kind: "one",
+					model: "subscription",
+					foreignKey: "subscriptionId"
+				}
+			}
+		},
+		paymentIntent: {
+			modelName: "payment_intent",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				amount: {
+					type: "number",
+					fieldName: "amount",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				currency: {
+					type: "string",
+					fieldName: "currency",
+					required: true,
+					defaultValue: Currency.KES,
+					sortable: true,
+					validator: {
+						input: z.enum(Currency).optional(),
+						output: z.enum(Currency)
+					}
+				},
+				phoneNumber: {
+					type: "string",
+					fieldName: "phone_number",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(15),
+						output: z.string()
+					}
+				},
+				provider: {
+					type: "string",
+					fieldName: "payment_provider",
+					required: true,
+					defaultValue: PaymentProviders.MPESA,
+					sortable: true,
+					validator: {
+						input: z.enum(PaymentProviders).optional(),
+						output: z.enum(PaymentProviders)
+					}
+				},
+				status: {
+					type: "string",
+					fieldName: "payment_intent_status",
+					required: true,
+					defaultValue: PaymentIntentStatus.REQUIRES_CONFIRMATION,
+					sortable: true,
+					validator: {
+						input: z.enum(PaymentIntentStatus).optional(),
+						output: z.enum(PaymentIntentStatus)
+					},
+					index: true
+				},
+				idempotencyKey: {
+					type: "uuid",
+					fieldName: "idempotency_key",
+					required: true,
+					unique: true,
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				providerTransactionId: {
+					type: "string",
+					fieldName: "provider_transaction_id",
+					required: true,
+					unique: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255),
+						output: z.string()
+					},
+					index: true
+				},
+				providerMetadata: {
+					type: "json",
+					fieldName: "provider_metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				customerId: {
+					type: "uuid",
+					fieldName: "customer_id",
+					required: true,
+					references: {
+						model: "customer",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				subscriptionId: {
+					type: "uuid",
+					fieldName: "subscription_id",
+					required: true,
+					references: {
+						model: "subscription",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				invoiceId: {
+					type: "uuid",
+					fieldName: "invoice_id",
+					required: true,
+					references: {
+						model: "invoice",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				description: {
+					type: "string",
+					fieldName: "payment_intent_description",
+					required: false
+				},
+				lastPaymentError: {
+					type: "json",
+					fieldName: "last_payment_error",
+					required: false,
+					returned: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				},
+				completedAt: {
+					type: "date",
+					fieldName: "completed_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				canceledAt: {
+					type: "date",
+					fieldName: "canceled_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "payment_intent_status_created_at_idx",
+					fields: ["status", "createdAt"]
+				},
+				{
+					name: "payment_intent_provider_transaction_id_idx",
+					fields: ["providerTransactionId"]
+				},
+				{
+					name: "payment_intent_customer_id_created_at_idx",
+					fields: ["customerId", "createdAt"]
+				},
+				{
+					name: "payment_intent_subscription_id_idx",
+					fields: ["subscriptionId"]
+				},
+				{
+					name: "payment_intent_invoice_id_idx",
+					fields: ["invoiceId"]
+				}
+			] },
+			checks: [{
+				name: "payment_intent_amount_gte_0",
+				kind: "gte",
+				field: "amount",
+				value: 0
+			}],
+			relations: {
+				customer: {
+					kind: "one",
+					model: "customer",
+					foreignKey: "customerId"
+				},
+				subscription: {
+					kind: "one",
+					model: "subscription",
+					foreignKey: "subscriptionId"
+				},
+				invoice: {
+					kind: "one",
+					model: "invoice",
+					foreignKey: "invoiceId"
+				},
+				checkoutSession: {
+					kind: "one",
+					model: "checkout_sessions",
+					foreignKey: "id"
+				},
+				transaction: {
+					kind: "one",
+					model: "transactions",
+					foreignKey: "id"
+				}
+			}
+		},
+		transaction: {
+			modelName: "transactions",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				amount: {
+					type: "number",
+					fieldName: "amount",
+					required: true,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int()
+					}
+				},
+				currency: {
+					type: "string",
+					fieldName: "currency",
+					required: true,
+					defaultValue: Currency.KES,
+					sortable: true,
+					validator: {
+						input: z.enum(Currency).optional(),
+						output: z.enum(Currency)
+					}
+				},
+				type: {
+					type: "string",
+					fieldName: "transaction_type",
+					required: true,
+					defaultValue: TransactionType.PAYMENT,
+					sortable: true,
+					validator: {
+						input: z.enum(TransactionType).optional(),
+						output: z.enum(TransactionType)
+					},
+					index: true
+				},
+				status: {
+					type: "string",
+					fieldName: "transaction_status",
+					required: true,
+					defaultValue: TransactionStatus.PENDING,
+					sortable: true,
+					validator: {
+						input: z.enum(TransactionStatus).optional(),
+						output: z.enum(TransactionStatus)
+					},
+					index: true
+				},
+				paymentIntentId: {
+					type: "uuid",
+					fieldName: "payment_intent_id",
+					required: true,
+					references: {
+						model: "payment_intent",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				customerId: {
+					type: "uuid",
+					fieldName: "customer_id",
+					required: true,
+					references: {
+						model: "customer",
+						field: "id",
+						onDelete: "cascade"
+					},
+					validator: {
+						input: z.uuid(),
+						output: z.uuid()
+					},
+					index: true
+				},
+				provider: {
+					type: "string",
+					fieldName: "payment_provider",
+					required: true,
+					defaultValue: PaymentProviders.MPESA,
+					sortable: true,
+					validator: {
+						input: z.enum(PaymentProviders).optional(),
+						output: z.enum(PaymentProviders)
+					}
+				},
+				providerReference: {
+					type: "string",
+					fieldName: "payment_provider_reference",
+					required: true,
+					sortable: true,
+					validator: {
+						input: z.string().max(255),
+						output: z.string()
+					},
+					index: true
+				},
+				providerMetadata: {
+					type: "json",
+					fieldName: "provider_metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				reversedById: {
+					type: "uuid",
+					fieldName: "reversed_by_id",
+					required: false,
+					validator: {
+						input: z.uuid().optional(),
+						output: z.uuid().optional()
+					},
+					index: true
+				},
+				description: {
+					type: "string",
+					fieldName: "transaction_description",
+					required: false
+				},
+				metadata: {
+					type: "json",
+					fieldName: "metadata",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "transactions_customer_id_created_at_idx",
+					fields: ["customerId", "createdAt"]
+				},
+				{
+					name: "transactions_status_type_created_at_idx",
+					fields: [
+						"status",
+						"type",
+						"createdAt"
+					]
+				},
+				{
+					name: "transactions_provider_reference_idx",
+					fields: ["providerReference"]
+				},
+				{
+					name: "transactions_reversed_by_id_idx",
+					fields: ["reversedById"]
+				}
+			] },
+			checks: [{
+				name: "transactions_amount_gte_0",
+				kind: "gte",
+				field: "amount",
+				value: 0
+			}],
+			relations: {
+				customer: {
+					kind: "one",
+					model: "customer",
+					foreignKey: "customerId"
+				},
+				paymentIntent: {
+					kind: "one",
+					model: "payment_intent",
+					foreignKey: "paymentIntentId"
+				},
+				reversedBy: {
+					kind: "one",
+					model: "transactions",
+					foreignKey: "reversedById"
+				},
+				reverses: {
+					kind: "many",
+					model: "transactions",
+					foreignKey: "reversedById"
+				}
+			}
+		},
+		scheduledTask: {
+			modelName: "scheduled_tasks",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				taskType: {
+					type: "string",
+					fieldName: "scheduled_task_type",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.enum(ScheduledTaskType).optional(),
+						output: z.enum(ScheduledTaskType).optional()
+					},
+					index: true
+				},
+				relatedObjectType: {
+					type: "string",
+					fieldName: "related_object_type",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(50).optional(),
+						output: z.string().max(50).optional()
+					},
+					index: true
+				},
+				relatedObjectId: {
+					type: "string",
+					fieldName: "related_object_id",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(255).optional(),
+						output: z.string().max(255).optional()
+					},
+					index: true
+				},
+				scheduledFor: {
+					type: "date",
+					fieldName: "scheduled_for",
+					required: false,
+					validator: {
+						input: z.date().optional(),
+						output: z.date().optional()
+					},
+					index: true
+				},
+				status: {
+					type: "string",
+					fieldName: "status",
+					required: false,
+					defaultValue: ScheduledTaskStatus.PENDING,
+					sortable: true,
+					validator: {
+						input: z.enum(ScheduledTaskStatus).optional(),
+						output: z.enum(ScheduledTaskStatus).optional()
+					},
+					index: true
+				},
+				attemptCount: {
+					type: "number",
+					fieldName: "attempt_count",
+					required: false,
+					defaultValue: 0,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				maxAttemptCount: {
+					type: "number",
+					fieldName: "max_attempt_count",
+					required: false,
+					defaultValue: 3,
+					validator: {
+						input: z.number().int().min(0).optional(),
+						output: z.number().int().optional()
+					}
+				},
+				lastAttemptAt: {
+					type: "date",
+					fieldName: "last_attempt_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				completedAt: {
+					type: "date",
+					fieldName: "completed_at",
+					required: false,
+					input: false,
+					returned: true,
+					validator: { output: z.date().optional() }
+				},
+				scheduledTaskResult: {
+					type: "json",
+					fieldName: "scheduled_task_result",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				error: {
+					type: "string",
+					fieldName: "error",
+					required: false
+				},
+				payload: {
+					type: "json",
+					fieldName: "payload",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				},
+				updatedAt: {
+					type: "date",
+					fieldName: "updated_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					onUpdate: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() }
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "scheduled_tasks_scheduled_for_status_idx",
+					fields: ["scheduledFor", "status"]
+				},
+				{
+					name: "scheduled_tasks_scheduled_for_status_task_type_idx",
+					fields: [
+						"scheduledFor",
+						"status",
+						"taskType"
+					]
+				},
+				{
+					name: "scheduled_tasks_related_object_type_related_object_id_idx",
+					fields: ["relatedObjectType", "relatedObjectId"]
+				}
+			] },
+			checks: [{
+				name: "scheduled_tasks_attempt_count_gte_0",
+				kind: "gte",
+				field: "attemptCount",
+				value: 0
+			}, {
+				name: "scheduled_tasks_max_attempt_count_gte_0",
+				kind: "gte",
+				field: "maxAttemptCount",
+				value: 0
+			}]
+		},
+		auditLog: {
+			modelName: "audit_logs",
+			order: 1,
+			fields: {
+				id: {
+					type: "uuid",
+					fieldName: "id",
+					required: true,
+					input: false,
+					returned: true,
+					unique: true,
+					validator: { output: z.uuid() }
+				},
+				action: {
+					type: "string",
+					fieldName: "audit_action",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.enum(AuditAction).optional(),
+						output: z.enum(AuditAction).optional()
+					},
+					index: true
+				},
+				actor: {
+					type: "string",
+					fieldName: "actor",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.enum(Actor).optional(),
+						output: z.enum(Actor).optional()
+					},
+					index: true
+				},
+				objectType: {
+					type: "string",
+					fieldName: "object_type",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(50).optional(),
+						output: z.string().max(50).optional()
+					},
+					index: true
+				},
+				objectId: {
+					type: "string",
+					fieldName: "object_id",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(255).optional(),
+						output: z.string().max(255).optional()
+					},
+					index: true
+				},
+				changes: {
+					type: "json",
+					fieldName: "changes",
+					required: false,
+					validator: {
+						input: z.unknown().optional(),
+						output: z.unknown().optional()
+					}
+				},
+				ipAddress: {
+					type: "string",
+					fieldName: "ip_address",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(45).optional(),
+						output: z.string().max(45).optional()
+					}
+				},
+				userAgent: {
+					type: "string",
+					fieldName: "user_agent",
+					required: false,
+					validator: {
+						input: z.string().optional(),
+						output: z.string().optional()
+					}
+				},
+				apiVersion: {
+					type: "string",
+					fieldName: "api_version",
+					required: false,
+					sortable: true,
+					validator: {
+						input: z.string().max(20).optional(),
+						output: z.string().max(20).optional()
+					}
+				},
+				createdAt: {
+					type: "date",
+					fieldName: "created_at",
+					required: true,
+					input: false,
+					returned: true,
+					defaultValue: () => /* @__PURE__ */ new Date(),
+					validator: { output: z.date() },
+					index: true
+				}
+			},
+			constraints: { indexes: [
+				{
+					name: "audit_logs_object_type_object_id_created_at_idx",
+					fields: [
+						"objectType",
+						"objectId",
+						"createdAt"
+					]
+				},
+				{
+					name: "audit_logs_created_at_action_idx",
+					fields: ["createdAt", "action"]
+				},
+				{
+					name: "audit_logs_actor_created_at_idx",
+					fields: ["actor", "createdAt"]
+				}
+			] }
+		},
+		...pluginTables
+	};
+};
+
+//#endregion
+export { initGetFieldAttributes as a, initGetDefaultModelName as c, initGetModelName as i, deepmerge as n, initGetIdField as o, withApplyDefault as r, initGetDefaultFieldName as s, getPaymentTables as t };