@86d-store/memberships 0.1.0

package/dist/admin/endpoints/routes.d.ts

@@ -0,0 +1,237 @@
+export declare const adminEndpoints: {
+    "/admin/memberships": import("better-call").StrictEndpoint<"/admin/memberships", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+            planId: import("zod").ZodOptional<import("zod").ZodString>;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                active: "active";
+                trial: "trial";
+                expired: "expired";
+                cancelled: "cancelled";
+                paused: "paused";
+            }>>;
+            take: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            skip: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        memberships: import("../..").Membership[];
+        total: number;
+    }>;
+    "/admin/memberships/stats": import("better-call").StrictEndpoint<"/admin/memberships/stats", {
+        method: "GET";
+    }, {
+        stats: import("../..").MembershipStats;
+    }>;
+    "/admin/memberships/plans": import("better-call").StrictEndpoint<"/admin/memberships/plans", {
+        method: "GET";
+        query: import("zod").ZodObject<{
+            active: import("zod").ZodOptional<import("zod").ZodEnum<{
+                true: "true";
+                false: "false";
+            }>>;
+            take: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+            skip: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        plans: import("../..").MembershipPlan[];
+        total: number;
+    }>;
+    "/admin/memberships/plans/create": import("better-call").StrictEndpoint<"/admin/memberships/plans/create", {
+        method: "POST";
+        body: import("zod").ZodObject<{
+            name: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>;
+            slug: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>;
+            price: import("zod").ZodNumber;
+            billingInterval: import("zod").ZodEnum<{
+                monthly: "monthly";
+                yearly: "yearly";
+                lifetime: "lifetime";
+            }>;
+            trialDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            isActive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            maxMembers: import("zod").ZodOptional<import("zod").ZodNumber>;
+            sortOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        plan?: never;
+    } | {
+        plan: import("../..").MembershipPlan;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/plans/:id/update": import("better-call").StrictEndpoint<"/admin/memberships/plans/:id/update", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            name: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>;
+            slug: import("zod").ZodOptional<import("zod").ZodString>;
+            description: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>>;
+            price: import("zod").ZodOptional<import("zod").ZodNumber>;
+            billingInterval: import("zod").ZodOptional<import("zod").ZodEnum<{
+                monthly: "monthly";
+                yearly: "yearly";
+                lifetime: "lifetime";
+            }>>;
+            trialDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            features: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
+            isActive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            maxMembers: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
+            sortOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        plan?: never;
+    } | {
+        plan: import("../..").MembershipPlan;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/plans/:id/delete": import("better-call").StrictEndpoint<"/admin/memberships/plans/:id/delete", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        success?: never;
+    } | {
+        success: boolean;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/plans/:planId/benefits/add": import("better-call").StrictEndpoint<"/admin/memberships/plans/:planId/benefits/add", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            planId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                discount_percentage: "discount_percentage";
+                free_shipping: "free_shipping";
+                early_access: "early_access";
+                exclusive_products: "exclusive_products";
+                priority_support: "priority_support";
+            }>;
+            value: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>>;
+            isActive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        benefit?: never;
+    } | {
+        benefit: import("../..").MembershipBenefit;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/plans/:planId/products/gate": import("better-call").StrictEndpoint<"/admin/memberships/plans/:planId/products/gate", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            planId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            productIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        gated?: never;
+    } | {
+        gated: number;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/plans/:planId/products/ungate": import("better-call").StrictEndpoint<"/admin/memberships/plans/:planId/products/ungate", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            planId: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        body: import("zod").ZodObject<{
+            productIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        ungated: number;
+    }>;
+    "/admin/memberships/benefits/:id/remove": import("better-call").StrictEndpoint<"/admin/memberships/benefits/:id/remove", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        success?: never;
+    } | {
+        success: boolean;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/:id": import("better-call").StrictEndpoint<"/admin/memberships/:id", {
+        method: "GET";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        membership?: never;
+        plan?: never;
+    } | {
+        membership: import("../..").Membership;
+        plan: import("../..").MembershipPlan | null;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/:id/cancel": import("better-call").StrictEndpoint<"/admin/memberships/:id/cancel", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        membership?: never;
+    } | {
+        membership: import("../..").Membership;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/:id/pause": import("better-call").StrictEndpoint<"/admin/memberships/:id/pause", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        membership?: never;
+    } | {
+        membership: import("../..").Membership;
+        error?: never;
+        status?: never;
+    }>;
+    "/admin/memberships/:id/resume": import("better-call").StrictEndpoint<"/admin/memberships/:id/resume", {
+        method: "POST";
+        params: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+    }, {
+        error: string;
+        status: number;
+        membership?: never;
+    } | {
+        membership: import("../..").Membership;
+        error?: never;
+        status?: never;
+    }>;
+};
+//# sourceMappingURL=routes.d.ts.map

package/dist/admin/endpoints/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/routes.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe1B,CAAC"}

package/dist/admin/endpoints/routes.js

@@ -0,0 +1,30 @@
+import { addBenefit } from "./add-benefit";
+import { cancelMembership } from "./cancel-membership";
+import { createPlan } from "./create-plan";
+import { deletePlan } from "./delete-plan";
+import { gateProduct } from "./gate-product";
+import { getMembership } from "./get-membership";
+import { getStats } from "./get-stats";
+import { listMemberships } from "./list-memberships";
+import { listPlans } from "./list-plans";
+import { pauseMembership } from "./pause-membership";
+import { removeBenefit } from "./remove-benefit";
+import { resumeMembership } from "./resume-membership";
+import { ungateProduct } from "./ungate-product";
+import { updatePlan } from "./update-plan";
+export const adminEndpoints = {
+    "/admin/memberships": listMemberships,
+    "/admin/memberships/stats": getStats,
+    "/admin/memberships/plans": listPlans,
+    "/admin/memberships/plans/create": createPlan,
+    "/admin/memberships/plans/:id/update": updatePlan,
+    "/admin/memberships/plans/:id/delete": deletePlan,
+    "/admin/memberships/plans/:planId/benefits/add": addBenefit,
+    "/admin/memberships/plans/:planId/products/gate": gateProduct,
+    "/admin/memberships/plans/:planId/products/ungate": ungateProduct,
+    "/admin/memberships/benefits/:id/remove": removeBenefit,
+    "/admin/memberships/:id": getMembership,
+    "/admin/memberships/:id/cancel": cancelMembership,
+    "/admin/memberships/:id/pause": pauseMembership,
+    "/admin/memberships/:id/resume": resumeMembership,
+};

package/dist/admin/endpoints/ungate-product.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const ungateProduct: import("better-call").StrictEndpoint<"/admin/memberships/plans/:planId/products/ungate", {
+    method: "POST";
+    params: z.ZodObject<{
+        planId: z.ZodString;
+    }, z.core.$strip>;
+    body: z.ZodObject<{
+        productIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, {
+    ungated: number;
+}>;
+//# sourceMappingURL=ungate-product.d.ts.map

package/dist/admin/endpoints/ungate-product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ungate-product.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/ungate-product.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,aAAa;;;;;;;;;;EAwBzB,CAAC"}

package/dist/admin/endpoints/ungate-product.js

@@ -0,0 +1,22 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { z } from "zod";
+export const ungateProduct = createAdminEndpoint("/admin/memberships/plans/:planId/products/ungate", {
+    method: "POST",
+    params: z.object({ planId: z.string().min(1) }),
+    body: z.object({
+        productIds: z.array(z.string().min(1)).min(1).max(100),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    let ungated = 0;
+    for (const productId of ctx.body.productIds) {
+        const removed = await controller.ungateProduct({
+            planId: ctx.params.planId,
+            productId,
+        });
+        if (removed)
+            ungated++;
+    }
+    return { ungated };
+});

package/dist/admin/endpoints/update-plan.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const updatePlan: import("better-call").StrictEndpoint<"/admin/memberships/plans/:id/update", {
+    method: "POST";
+    params: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    body: z.ZodObject<{
+        name: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        slug: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+        price: z.ZodOptional<z.ZodNumber>;
+        billingInterval: z.ZodOptional<z.ZodEnum<{
+            monthly: "monthly";
+            yearly: "yearly";
+            lifetime: "lifetime";
+        }>>;
+        trialDays: z.ZodOptional<z.ZodNumber>;
+        features: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        maxMembers: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, {
+    error: string;
+    status: number;
+    plan?: never;
+} | {
+    plan: import("../..").MembershipPlan;
+    error?: never;
+    status?: never;
+}>;
+//# sourceMappingURL=update-plan.d.ts.map

package/dist/admin/endpoints/update-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-plan.d.ts","sourceRoot":"","sources":["../../../src/admin/endpoints/update-plan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4DtB,CAAC"}

package/dist/admin/endpoints/update-plan.js

@@ -0,0 +1,62 @@
+import { createAdminEndpoint } from "@86d-store/core/api";
+import { sanitizeText } from "@86d-store/core/sanitize";
+import { z } from "zod";
+export const updatePlan = createAdminEndpoint("/admin/memberships/plans/:id/update", {
+    method: "POST",
+    params: z.object({ id: z.string().min(1) }),
+    body: z.object({
+        name: z.string().min(1).max(200).transform(sanitizeText).optional(),
+        slug: z.string().min(1).max(200).optional(),
+        description: z
+            .string()
+            .max(5000)
+            .transform(sanitizeText)
+            .nullable()
+            .optional(),
+        price: z.number().min(0).optional(),
+        billingInterval: z.enum(["monthly", "yearly", "lifetime"]).optional(),
+        trialDays: z.number().int().min(0).max(365).optional(),
+        features: z.array(z.string().max(500)).max(50).nullable().optional(),
+        isActive: z.boolean().optional(),
+        maxMembers: z.number().int().min(1).nullable().optional(),
+        sortOrder: z.number().int().min(0).max(10000).optional(),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers
+        .memberships;
+    if (ctx.body.slug != null) {
+        const existing = await controller.getPlanBySlug(ctx.body.slug);
+        if (existing && existing.id !== ctx.params.id) {
+            return {
+                error: "A plan with this slug already exists",
+                status: 400,
+            };
+        }
+    }
+    const updateParams = {};
+    if (ctx.body.name != null)
+        updateParams.name = ctx.body.name;
+    if (ctx.body.slug != null)
+        updateParams.slug = ctx.body.slug;
+    if (ctx.body.description !== undefined)
+        updateParams.description = ctx.body.description;
+    if (ctx.body.price != null)
+        updateParams.price = ctx.body.price;
+    if (ctx.body.billingInterval != null)
+        updateParams.billingInterval = ctx.body.billingInterval;
+    if (ctx.body.trialDays != null)
+        updateParams.trialDays = ctx.body.trialDays;
+    if (ctx.body.features !== undefined)
+        updateParams.features = ctx.body.features;
+    if (ctx.body.isActive != null)
+        updateParams.isActive = ctx.body.isActive;
+    if (ctx.body.maxMembers !== undefined)
+        updateParams.maxMembers = ctx.body.maxMembers;
+    if (ctx.body.sortOrder != null)
+        updateParams.sortOrder = ctx.body.sortOrder;
+    const plan = await controller.updatePlan(ctx.params.id, updateParams);
+    if (!plan) {
+        return { error: "Plan not found", status: 404 };
+    }
+    return { plan };
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { Module, ModuleConfig } from "@86d-store/core/types/module";
+export type { BenefitType, BillingInterval, Membership, MembershipBenefit, MembershipController, MembershipPlan, MembershipProduct, MembershipStats, MembershipStatus, MembershipWithPlan, } from "./service";
+export interface MembershipsOptions extends ModuleConfig {
+    /** Default trial days for new plans when not specified. Default: "0". */
+    defaultTrialDays?: string;
+    /** Maximum members allowed per plan when not specified. No default (unlimited). */
+    defaultMaxMembers?: string;
+}
+export default function memberships(options?: MembershipsOptions): Module;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EACN,YAAY,EAEZ,MAAM,8BAA8B,CAAC;AAMtC,YAAY,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GAClB,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACvD,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAsExE"}

package/dist/index.js

@@ -0,0 +1,75 @@
+import { adminEndpoints } from "./admin/endpoints/routes";
+import { membershipsStorage } from "./schema";
+import { createMembershipController } from "./service-impl";
+import { storeEndpoints } from "./store/endpoints/routes";
+export default function memberships(options) {
+    return {
+        id: "memberships",
+        version: "0.0.1",
+        storage: membershipsStorage,
+        exports: {
+            read: [
+                "activePlans",
+                "customerMembership",
+                "customerBenefits",
+                "productAccess",
+            ],
+        },
+        requires: ["customers"],
+        events: {
+            emits: [
+                "membership.subscribed",
+                "membership.cancelled",
+                "membership.paused",
+                "membership.resumed",
+                "membership.expired",
+                "membership.plan.created",
+                "membership.plan.updated",
+                "membership.plan.deleted",
+                "membership.benefit.added",
+                "membership.benefit.removed",
+                "membership.product.gated",
+                "membership.product.ungated",
+            ],
+        },
+        init: async (ctx) => {
+            const controller = createMembershipController(ctx.data);
+            return { controllers: { memberships: controller } };
+        },
+        endpoints: {
+            store: storeEndpoints,
+            admin: adminEndpoints,
+        },
+        admin: {
+            pages: [
+                {
+                    path: "/admin/memberships",
+                    component: "MembershipAdmin",
+                    label: "Memberships",
+                    icon: "Crown",
+                    group: "Customers",
+                },
+                {
+                    path: "/admin/memberships/plans",
+                    component: "MembershipPlans",
+                    label: "Plans",
+                    icon: "Layers",
+                    group: "Customers",
+                },
+            ],
+        },
+        store: {
+            pages: [
+                {
+                    path: "/memberships",
+                    component: "PlanListing",
+                },
+                {
+                    path: "/memberships/:slug",
+                    component: "PlanDetail",
+                },
+            ],
+        },
+        options,
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export declare const membershipsMembershipPlanShape: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    price: z.ZodNumber;
+    billingInterval: z.ZodString;
+    trialDays: z.ZodNumber;
+    features: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    isActive: z.ZodBoolean;
+    maxMembers: z.ZodOptional<z.ZodNumber>;
+    sortOrder: z.ZodNumber;
+    createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const membershipsMembershipShape: z.ZodObject<{
+    id: z.ZodString;
+    customerId: z.ZodString;
+    planId: z.ZodString;
+    status: z.ZodString;
+    startDate: z.ZodCoercedDate<unknown>;
+    endDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    trialEndDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    cancelledAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    pausedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const membershipsMembershipBenefitShape: z.ZodObject<{
+    id: z.ZodString;
+    planId: z.ZodString;
+    type: z.ZodString;
+    value: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+    createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const membershipsMembershipProductShape: z.ZodObject<{
+    id: z.ZodString;
+    planId: z.ZodString;
+    productId: z.ZodString;
+    assignedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+/** Native Relational storage for memberships. */
+export declare const membershipsStorage: {
+    readonly kind: "relational";
+    readonly tables: {
+        readonly membershipPlan: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                slug: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                price: z.ZodNumber;
+                billingInterval: z.ZodString;
+                trialDays: z.ZodNumber;
+                features: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                isActive: z.ZodBoolean;
+                maxMembers: z.ZodOptional<z.ZodNumber>;
+                sortOrder: z.ZodNumber;
+                createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly membership: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                customerId: z.ZodString;
+                planId: z.ZodString;
+                status: z.ZodString;
+                startDate: z.ZodCoercedDate<unknown>;
+                endDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                trialEndDate: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                cancelledAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                pausedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly membershipBenefit: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                planId: z.ZodString;
+                type: z.ZodString;
+                value: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                isActive: z.ZodBoolean;
+                createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly membershipProduct: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                planId: z.ZodString;
+                productId: z.ZodString;
+                assignedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;iBAczC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;iBAYrC,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;iBAQ5C,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;iBAK5C,CAAC;AAEH,iDAAiD;AACjD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBc,CAAC"}