@mohasinac/appkit 2.4.11 → 2.5.1

package/dist/_internal/shared/features/products/schema.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+const priceSchema = z.number().int().min(0, "Price must be non-negative (paise)");
+const conditionSchema = z.enum(["new", "like_new", "good", "fair", "poor", "used", "refurbished", "broken"]);
+export const productInputSchema = z.object({
+    title: z.string().min(3, "Title must be at least 3 characters").max(200),
+    description: z.string().max(10000).optional(),
+    category: z.string().min(1, "Category is required"),
+    brandSlug: z.string().optional(),
+    price: priceSchema,
+    currency: z.string().default("INR"),
+    stockQuantity: z.number().int().min(0).default(0),
+    availableQuantity: z.number().int().min(0).default(0),
+    mainImage: z.string().url("mainImage must be a valid URL"),
+    images: z.array(z.string().url()).max(20).default([]),
+    condition: conditionSchema.optional(),
+    tags: z.array(z.string()).max(20).default([]),
+    seoTitle: z.string().max(70).optional(),
+    seoDescription: z.string().max(160).optional(),
+    seoKeywords: z.array(z.string()).max(10).optional(),
+    shippingInfo: z.string().max(1000).optional(),
+    returnPolicy: z.string().max(1000).optional(),
+    shippingPaidBy: z.enum(["seller", "buyer"]).optional(),
+    insurance: z.boolean().optional(),
+    insuranceCost: z.number().int().min(0).optional(),
+    allowOffers: z.boolean().optional(),
+    minOfferPercent: z.number().min(0).max(100).optional(),
+    features: z.array(z.string()).max(50).optional(),
+});
+export const productUpdateSchema = productInputSchema.partial();
+export const auctionInputSchema = productInputSchema.extend({
+    // SB1-G — canonical discriminator. Locked to "auction" via literal.
+    listingType: z.literal("auction"),
+    startingBid: priceSchema,
+    reservePrice: priceSchema.optional(),
+    buyNowPrice: priceSchema.optional(),
+    minBidIncrement: z.number().int().min(1).optional(),
+    auctionEndDate: z.string().datetime({ offset: true }),
+    autoExtendable: z.boolean().default(false),
+    auctionExtensionMinutes: z.number().int().min(1).max(30).optional(),
+    auctionShippingPaidBy: z.enum(["seller", "winner"]).optional(),
+});
+export const preOrderInputSchema = productInputSchema.extend({
+    // SB1-G — canonical discriminator. Locked to "pre-order" via literal.
+    listingType: z.literal("pre-order"),
+    preOrderDeliveryDate: z.string().datetime({ offset: true }),
+    preOrderDepositPercent: z.number().min(0).max(100).optional(),
+    preOrderMaxQuantity: z.number().int().min(1).optional(),
+    preOrderProductionStatus: z.enum(["upcoming", "in_production", "ready_to_ship"]).default("upcoming"),
+    preOrderCancellable: z.boolean().default(true),
+});
+export const setFeaturedSchema = z.object({
+    productId: z.string().min(1),
+    featured: z.boolean(),
+});
+export const setStatusSchema = z.object({
+    productId: z.string().min(1),
+    status: z.enum(["draft", "published", "archived"]),
+});

package/dist/_internal/shared/features/products/types.d.ts

@@ -0,0 +1,46 @@
+export type { ProductStatus, ProductCondition, ListingType, ProductItem, ProductListResponse, ProductListParams, ProductImage, ProductSeo, } from "../../../../features/products/types/index";
+export type { ProductDocument, CustomField, CustomSection, ProductSpecification, } from "../../../../features/products/schemas/firestore";
+export type { ProductFeatureDocument } from "../../../../features/products/schemas/product-features";
+/** Serializable shape passed from server page → client view as initialData. */
+export interface ProductDetailInitial {
+    id: string;
+    title: string;
+    slug?: string;
+    description?: string;
+    seoTitle?: string;
+    seoDescription?: string;
+    seoKeywords?: string[];
+    price: number;
+    currency: string;
+    mainImage: string;
+    images: string[];
+    status: string;
+    storeId: string;
+    storeName?: string;
+    featured: boolean;
+    tags: string[];
+    condition?: string;
+    /** Canonical listing-kind discriminator (SB1-G — Phase 4 dropped legacy booleans). */
+    listingType?: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle";
+    auctionEndDate?: string;
+    startingBid?: number;
+    currentBid?: number;
+    bidCount?: number;
+    reservePrice?: number;
+    buyNowPrice?: number;
+    minBidIncrement?: number;
+    autoExtendable?: boolean;
+    preOrderDeliveryDate?: string;
+    preOrderDepositPercent?: number;
+    preOrderMaxQuantity?: number;
+    preOrderCurrentCount?: number;
+    preOrderProductionStatus?: string;
+    allowOffers?: boolean;
+    availableQuantity: number;
+    stockQuantity: number;
+    avgRating?: number;
+    reviewCount?: number;
+    viewCount?: number;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/_internal/shared/features/products/types.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/shared/features/promotions/config.d.ts

@@ -0,0 +1,3 @@
+export declare const COUPONS_PAGE_SIZE = 20;
+export declare const COUPON_CODE_MAX_LENGTH = 20;
+export declare const COUPON_CODE_PATTERN: RegExp;

package/dist/_internal/shared/features/promotions/config.js

@@ -0,0 +1,3 @@
+export const COUPONS_PAGE_SIZE = 20;
+export const COUPON_CODE_MAX_LENGTH = 20;
+export const COUPON_CODE_PATTERN = /^[A-Z0-9_-]{3,20}$/;

package/dist/_internal/shared/features/promotions/errors.d.ts

@@ -0,0 +1,19 @@
+import { NotFoundError, ConflictError, ValidationError, ExpiredError } from "../../errors/index";
+export declare class CouponNotFoundError extends NotFoundError {
+    constructor(code: string);
+}
+export declare class CouponExpiredError extends ExpiredError {
+    constructor(code: string);
+}
+export declare class CouponUsageLimitError extends ConflictError {
+    constructor(code: string);
+}
+export declare class CouponPerUserLimitError extends ConflictError {
+    constructor(code: string);
+}
+export declare class CouponMinPurchaseError extends ValidationError {
+    constructor(minAmount: number);
+}
+export declare class CouponScopeError extends ValidationError {
+    constructor();
+}

package/dist/_internal/shared/features/promotions/errors.js

@@ -0,0 +1,37 @@
+import { NotFoundError, ConflictError, ValidationError, ExpiredError } from "../../errors/index";
+export class CouponNotFoundError extends NotFoundError {
+    constructor(code) {
+        super("Coupon", code);
+        this.name = "CouponNotFoundError";
+    }
+}
+export class CouponExpiredError extends ExpiredError {
+    constructor(code) {
+        super(`Coupon ${code}`);
+        this.name = "CouponExpiredError";
+    }
+}
+export class CouponUsageLimitError extends ConflictError {
+    constructor(code) {
+        super(`Coupon "${code}" has reached its usage limit`);
+        this.name = "CouponUsageLimitError";
+    }
+}
+export class CouponPerUserLimitError extends ConflictError {
+    constructor(code) {
+        super(`You have already used coupon "${code}" the maximum number of times`);
+        this.name = "CouponPerUserLimitError";
+    }
+}
+export class CouponMinPurchaseError extends ValidationError {
+    constructor(minAmount) {
+        super(`Minimum purchase of ₹${(minAmount / 100).toLocaleString("en-IN")} required for this coupon`, "total");
+        this.name = "CouponMinPurchaseError";
+    }
+}
+export class CouponScopeError extends ValidationError {
+    constructor() {
+        super("This coupon is not valid for your cart");
+        this.name = "CouponScopeError";
+    }
+}

package/dist/_internal/shared/features/promotions/schema.d.ts

@@ -0,0 +1,242 @@
+import { z } from "zod";
+export declare const applyCouponSchema: z.ZodObject<{
+    code: z.ZodString;
+    cartTotal: z.ZodNumber;
+    productIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    categoryIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFirstTimeUser: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    cartTotal: number;
+    isFirstTimeUser: boolean;
+    productIds?: string[] | undefined;
+    categoryIds?: string[] | undefined;
+}, {
+    code: string;
+    cartTotal: number;
+    productIds?: string[] | undefined;
+    categoryIds?: string[] | undefined;
+    isFirstTimeUser?: boolean | undefined;
+}>;
+export declare const createCouponSchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<["percentage", "fixed", "free_shipping", "buy_x_get_y"]>;
+    scope: z.ZodEnum<["admin", "seller"]>;
+    sellerId: z.ZodOptional<z.ZodString>;
+    discount: z.ZodObject<{
+        value: z.ZodNumber;
+        maxDiscount: z.ZodOptional<z.ZodNumber>;
+        minPurchase: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        minPurchase: number;
+        maxDiscount?: number | undefined;
+    }, {
+        value: number;
+        maxDiscount?: number | undefined;
+        minPurchase?: number | undefined;
+    }>;
+    usage: z.ZodObject<{
+        totalLimit: z.ZodOptional<z.ZodNumber>;
+        perUserLimit: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        perUserLimit: number;
+        totalLimit?: number | undefined;
+    }, {
+        perUserLimit?: number | undefined;
+        totalLimit?: number | undefined;
+    }>;
+    validity: z.ZodObject<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        isActive: boolean;
+        endDate: string;
+        startDate: string;
+    }, {
+        endDate: string;
+        startDate: string;
+        isActive?: boolean | undefined;
+    }>;
+    restrictions: z.ZodOptional<z.ZodObject<{
+        firstTimeUserOnly: z.ZodDefault<z.ZodBoolean>;
+        combineWithSellerCoupons: z.ZodDefault<z.ZodBoolean>;
+        applicableProducts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        applicableCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        firstTimeUserOnly: boolean;
+        combineWithSellerCoupons: boolean;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    }, {
+        firstTimeUserOnly?: boolean | undefined;
+        combineWithSellerCoupons?: boolean | undefined;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    type: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y";
+    scope: "admin" | "seller";
+    name: string;
+    discount: {
+        value: number;
+        minPurchase: number;
+        maxDiscount?: number | undefined;
+    };
+    usage: {
+        perUserLimit: number;
+        totalLimit?: number | undefined;
+    };
+    validity: {
+        isActive: boolean;
+        endDate: string;
+        startDate: string;
+    };
+    sellerId?: string | undefined;
+    restrictions?: {
+        firstTimeUserOnly: boolean;
+        combineWithSellerCoupons: boolean;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    } | undefined;
+}, {
+    code: string;
+    type: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y";
+    scope: "admin" | "seller";
+    name: string;
+    discount: {
+        value: number;
+        maxDiscount?: number | undefined;
+        minPurchase?: number | undefined;
+    };
+    usage: {
+        perUserLimit?: number | undefined;
+        totalLimit?: number | undefined;
+    };
+    validity: {
+        endDate: string;
+        startDate: string;
+        isActive?: boolean | undefined;
+    };
+    sellerId?: string | undefined;
+    restrictions?: {
+        firstTimeUserOnly?: boolean | undefined;
+        combineWithSellerCoupons?: boolean | undefined;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    } | undefined;
+}>;
+export declare const updateCouponSchema: z.ZodObject<Omit<{
+    code: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["percentage", "fixed", "free_shipping", "buy_x_get_y"]>>;
+    scope: z.ZodOptional<z.ZodEnum<["admin", "seller"]>>;
+    sellerId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    discount: z.ZodOptional<z.ZodObject<{
+        value: z.ZodNumber;
+        maxDiscount: z.ZodOptional<z.ZodNumber>;
+        minPurchase: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        value: number;
+        minPurchase: number;
+        maxDiscount?: number | undefined;
+    }, {
+        value: number;
+        maxDiscount?: number | undefined;
+        minPurchase?: number | undefined;
+    }>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        totalLimit: z.ZodOptional<z.ZodNumber>;
+        perUserLimit: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        perUserLimit: number;
+        totalLimit?: number | undefined;
+    }, {
+        perUserLimit?: number | undefined;
+        totalLimit?: number | undefined;
+    }>>;
+    validity: z.ZodOptional<z.ZodObject<{
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        isActive: boolean;
+        endDate: string;
+        startDate: string;
+    }, {
+        endDate: string;
+        startDate: string;
+        isActive?: boolean | undefined;
+    }>>;
+    restrictions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        firstTimeUserOnly: z.ZodDefault<z.ZodBoolean>;
+        combineWithSellerCoupons: z.ZodDefault<z.ZodBoolean>;
+        applicableProducts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        applicableCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        firstTimeUserOnly: boolean;
+        combineWithSellerCoupons: boolean;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    }, {
+        firstTimeUserOnly?: boolean | undefined;
+        combineWithSellerCoupons?: boolean | undefined;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    }>>>;
+}, "code">, "strip", z.ZodTypeAny, {
+    type?: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y" | undefined;
+    scope?: "admin" | "seller" | undefined;
+    name?: string | undefined;
+    discount?: {
+        value: number;
+        minPurchase: number;
+        maxDiscount?: number | undefined;
+    } | undefined;
+    sellerId?: string | undefined;
+    usage?: {
+        perUserLimit: number;
+        totalLimit?: number | undefined;
+    } | undefined;
+    validity?: {
+        isActive: boolean;
+        endDate: string;
+        startDate: string;
+    } | undefined;
+    restrictions?: {
+        firstTimeUserOnly: boolean;
+        combineWithSellerCoupons: boolean;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    } | undefined;
+}, {
+    type?: "fixed" | "percentage" | "free_shipping" | "buy_x_get_y" | undefined;
+    scope?: "admin" | "seller" | undefined;
+    name?: string | undefined;
+    discount?: {
+        value: number;
+        maxDiscount?: number | undefined;
+        minPurchase?: number | undefined;
+    } | undefined;
+    sellerId?: string | undefined;
+    usage?: {
+        perUserLimit?: number | undefined;
+        totalLimit?: number | undefined;
+    } | undefined;
+    validity?: {
+        endDate: string;
+        startDate: string;
+        isActive?: boolean | undefined;
+    } | undefined;
+    restrictions?: {
+        firstTimeUserOnly?: boolean | undefined;
+        combineWithSellerCoupons?: boolean | undefined;
+        applicableProducts?: string[] | undefined;
+        applicableCategories?: string[] | undefined;
+    } | undefined;
+}>;
+export type ApplyCouponInput = z.infer<typeof applyCouponSchema>;
+export type CreateCouponInput = z.infer<typeof createCouponSchema>;

package/dist/_internal/shared/features/promotions/schema.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { COUPON_CODE_PATTERN } from "./config";
+export const applyCouponSchema = z.object({
+    code: z.string().regex(COUPON_CODE_PATTERN, "Invalid coupon code format").toUpperCase(),
+    cartTotal: z.number().int().min(0),
+    productIds: z.array(z.string()).optional(),
+    categoryIds: z.array(z.string()).optional(),
+    isFirstTimeUser: z.boolean().default(false),
+});
+export const createCouponSchema = z.object({
+    code: z.string().regex(COUPON_CODE_PATTERN, "Invalid coupon code format"),
+    name: z.string().min(1).max(100),
+    type: z.enum(["percentage", "fixed", "free_shipping", "buy_x_get_y"]),
+    scope: z.enum(["admin", "seller"]),
+    sellerId: z.string().optional(),
+    discount: z.object({
+        value: z.number().min(0),
+        maxDiscount: z.number().int().min(0).optional(),
+        minPurchase: z.number().int().min(0).default(0),
+    }),
+    usage: z.object({
+        totalLimit: z.number().int().min(1).optional(),
+        perUserLimit: z.number().int().min(1).default(1),
+    }),
+    validity: z.object({
+        startDate: z.string().datetime({ offset: true }),
+        endDate: z.string().datetime({ offset: true }),
+        isActive: z.boolean().default(true),
+    }),
+    restrictions: z.object({
+        firstTimeUserOnly: z.boolean().default(false),
+        combineWithSellerCoupons: z.boolean().default(false),
+        applicableProducts: z.array(z.string()).optional(),
+        applicableCategories: z.array(z.string()).optional(),
+    }).optional(),
+});
+export const updateCouponSchema = createCouponSchema.partial().omit({ code: true });

package/dist/_internal/shared/features/reviews/config.d.ts

@@ -0,0 +1,8 @@
+export declare const REVIEWS_PAGE_SIZE = 20;
+export declare const REVIEW_BODY_MAX_LENGTH = 2000;
+export declare const REVIEW_TITLE_MAX_LENGTH = 100;
+export declare const REVIEW_MIN_RATING = 1;
+export declare const REVIEW_MAX_RATING = 5;
+export declare const REVIEW_IMAGES_MAX = 5;
+export declare const REVIEW_REPLY_MAX_LENGTH = 1000;
+export declare const REVIEW_BODY_MIN_LENGTH = 10;

package/dist/_internal/shared/features/reviews/config.js

@@ -0,0 +1,8 @@
+export const REVIEWS_PAGE_SIZE = 20;
+export const REVIEW_BODY_MAX_LENGTH = 2000;
+export const REVIEW_TITLE_MAX_LENGTH = 100;
+export const REVIEW_MIN_RATING = 1;
+export const REVIEW_MAX_RATING = 5;
+export const REVIEW_IMAGES_MAX = 5;
+export const REVIEW_REPLY_MAX_LENGTH = 1000;
+export const REVIEW_BODY_MIN_LENGTH = 10;

package/dist/_internal/shared/features/reviews/errors.d.ts

@@ -0,0 +1,13 @@
+import { NotFoundError, ConflictError, UnauthorizedError } from "../../errors/index";
+export declare class ReviewNotFoundError extends NotFoundError {
+    constructor(id: string);
+}
+export declare class DuplicateReviewError extends ConflictError {
+    constructor(productId: string);
+}
+export declare class ReviewOwnershipError extends UnauthorizedError {
+    constructor();
+}
+export declare class ReviewNotVerifiedError extends ConflictError {
+    constructor();
+}

package/dist/_internal/shared/features/reviews/errors.js

@@ -0,0 +1,25 @@
+import { NotFoundError, ConflictError, UnauthorizedError } from "../../errors/index";
+export class ReviewNotFoundError extends NotFoundError {
+    constructor(id) {
+        super("Review", id);
+        this.name = "ReviewNotFoundError";
+    }
+}
+export class DuplicateReviewError extends ConflictError {
+    constructor(productId) {
+        super(`You have already reviewed product ${productId}`);
+        this.name = "DuplicateReviewError";
+    }
+}
+export class ReviewOwnershipError extends UnauthorizedError {
+    constructor() {
+        super("modify this review");
+        this.name = "ReviewOwnershipError";
+    }
+}
+export class ReviewNotVerifiedError extends ConflictError {
+    constructor() {
+        super("You must purchase this product before reviewing it");
+        this.name = "ReviewNotVerifiedError";
+    }
+}

package/dist/_internal/shared/features/reviews/schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const createReviewSchema: z.ZodObject<{
+    productId: z.ZodString;
+    storeId: z.ZodString;
+    rating: z.ZodNumber;
+    title: z.ZodString;
+    body: z.ZodString;
+    images: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    orderId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    storeId: string;
+    title: string;
+    body: string;
+    productId: string;
+    images: string[];
+    rating: number;
+    orderId?: string | undefined;
+}, {
+    storeId: string;
+    title: string;
+    body: string;
+    productId: string;
+    rating: number;
+    orderId?: string | undefined;
+    images?: string[] | undefined;
+}>;
+export declare const replyToReviewSchema: z.ZodObject<{
+    reviewId: z.ZodString;
+    reply: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reviewId: string;
+    reply: string;
+}, {
+    reviewId: string;
+    reply: string;
+}>;
+export declare const deleteReviewSchema: z.ZodObject<{
+    reviewId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reviewId: string;
+}, {
+    reviewId: string;
+}>;
+export type CreateReviewInput = z.infer<typeof createReviewSchema>;

package/dist/_internal/shared/features/reviews/schema.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { REVIEW_BODY_MAX_LENGTH, REVIEW_BODY_MIN_LENGTH, REVIEW_TITLE_MAX_LENGTH, REVIEW_MIN_RATING, REVIEW_MAX_RATING, REVIEW_IMAGES_MAX, REVIEW_REPLY_MAX_LENGTH, } from "./config";
+export const createReviewSchema = z.object({
+    productId: z.string().min(1),
+    storeId: z.string().min(1),
+    rating: z.number().int().min(REVIEW_MIN_RATING).max(REVIEW_MAX_RATING),
+    title: z.string().min(1).max(REVIEW_TITLE_MAX_LENGTH),
+    body: z.string().min(REVIEW_BODY_MIN_LENGTH).max(REVIEW_BODY_MAX_LENGTH),
+    images: z.array(z.string().url()).max(REVIEW_IMAGES_MAX).default([]),
+    orderId: z.string().optional(),
+});
+export const replyToReviewSchema = z.object({
+    reviewId: z.string().min(1),
+    reply: z.string().min(1).max(REVIEW_REPLY_MAX_LENGTH),
+});
+export const deleteReviewSchema = z.object({
+    reviewId: z.string().min(1),
+});

package/dist/_internal/shared/features/stores/config.d.ts

@@ -0,0 +1,4 @@
+export declare const STORES_PAGE_SIZE = 20;
+export declare const STORES_PRODUCTS_PAGE_SIZE = 24;
+export declare const STORES_SITEMAP_LIMIT = 200;
+export declare const STORES_FEATURED_LIMIT = 8;

package/dist/_internal/shared/features/stores/config.js

@@ -0,0 +1,4 @@
+export const STORES_PAGE_SIZE = 20;
+export const STORES_PRODUCTS_PAGE_SIZE = 24;
+export const STORES_SITEMAP_LIMIT = 200;
+export const STORES_FEATURED_LIMIT = 8;

package/dist/_internal/shared/features/wishlist/config.d.ts

@@ -0,0 +1,2 @@
+export declare const WISHLIST_MAX = 20;
+export declare const WISHLIST_GUEST_STORAGE_KEY = "appkit:wishlist";

package/dist/_internal/shared/features/wishlist/config.js

@@ -0,0 +1,2 @@
+export const WISHLIST_MAX = 20;
+export const WISHLIST_GUEST_STORAGE_KEY = "appkit:wishlist";

package/dist/_internal/shared/features/wishlist/errors.d.ts

@@ -0,0 +1,4 @@
+import { CapacityError } from "../../errors/index";
+export declare class WishlistCapError extends CapacityError {
+    constructor(current: number, max: number);
+}

package/dist/_internal/shared/features/wishlist/errors.js

@@ -0,0 +1,7 @@
+import { CapacityError } from "../../errors/index";
+export class WishlistCapError extends CapacityError {
+    constructor(current, max) {
+        super(`Wishlist is full (${current}/${max})`);
+        this.name = "WishlistCapError";
+    }
+}

package/dist/_internal/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./tokens";
+export * from "./config";

package/dist/_internal/shared/index.js

@@ -0,0 +1,4 @@
+// Shared types, schemas, constants, utils — populated starting in S2
+// Boundary rule: no React, no firebase-admin, no _internal/client or _internal/server imports
+export * from "./tokens";
+export * from "./config";

package/dist/_internal/shared/serialization/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hydration helpers — narrow the gap between Firestore document shapes
+ * (which contain Timestamps, server FieldValues, undefined fields, etc.)
+ * and serializable JSON suitable for crossing the RSC boundary.
+ *
+ * Usage:
+ *   const product = await getProductForDetail(slug);
+ *   return <ProductView initialProduct={toClient(product)} />;
+ */
+/** Recursive transform: any non-serializable value becomes a plain JSON value. */
+export declare function toClient<T>(value: T): T;
+/**
+ * Typed wrapper for passing an SSR-fetched value to a client component as
+ * `initialX` props. Mostly cosmetic — it documents intent and ensures the
+ * input went through `toClient()`.
+ */
+export declare function clientInitial<T>(value: T): T;