@contractspec/example.marketplace 1.56.1 → 1.58.0

package/dist/browser/entities/order.js

@@ -0,0 +1,167 @@
+// src/entities/order.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var OrderStatusEnum = defineEntityEnum({
+  name: "OrderStatus",
+  values: [
+    "PENDING",
+    "PAID",
+    "PROCESSING",
+    "SHIPPED",
+    "DELIVERED",
+    "COMPLETED",
+    "CANCELLED",
+    "REFUNDED",
+    "PARTIALLY_REFUNDED",
+    "DISPUTED"
+  ],
+  schema: "marketplace",
+  description: "Status of an order."
+});
+var PaymentStatusEnum = defineEntityEnum({
+  name: "PaymentStatus",
+  values: [
+    "PENDING",
+    "AUTHORIZED",
+    "CAPTURED",
+    "FAILED",
+    "REFUNDED",
+    "VOIDED"
+  ],
+  schema: "marketplace",
+  description: "Status of payment."
+});
+var OrderEntity = defineEntity({
+  name: "Order",
+  description: "A purchase order on the marketplace.",
+  schema: "marketplace",
+  map: "order",
+  fields: {
+    id: field.id({ description: "Unique order ID" }),
+    orderNumber: field.string({ description: "Human-readable order number" }),
+    buyerId: field.foreignKey({ description: "Buyer user ID" }),
+    storeId: field.foreignKey({ description: "Seller store ID" }),
+    status: field.enum("OrderStatus", { default: "PENDING" }),
+    paymentStatus: field.enum("PaymentStatus", { default: "PENDING" }),
+    subtotal: field.decimal({ description: "Sum of item prices" }),
+    shippingTotal: field.decimal({ default: 0 }),
+    taxTotal: field.decimal({ default: 0 }),
+    discountTotal: field.decimal({ default: 0 }),
+    total: field.decimal({ description: "Final total" }),
+    currency: field.string({ default: '"USD"' }),
+    platformFee: field.decimal({ description: "Platform commission amount" }),
+    sellerPayout: field.decimal({ description: "Amount due to seller" }),
+    shippingAddress: field.json({ isOptional: true }),
+    billingAddress: field.json({ isOptional: true }),
+    shippingMethod: field.string({ isOptional: true }),
+    trackingNumber: field.string({ isOptional: true }),
+    trackingUrl: field.string({ isOptional: true }),
+    paymentMethod: field.string({ isOptional: true }),
+    paymentIntentId: field.string({ isOptional: true }),
+    buyerNote: field.string({ isOptional: true }),
+    sellerNote: field.string({ isOptional: true }),
+    internalNote: field.string({ isOptional: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    paidAt: field.dateTime({ isOptional: true }),
+    shippedAt: field.dateTime({ isOptional: true }),
+    deliveredAt: field.dateTime({ isOptional: true }),
+    completedAt: field.dateTime({ isOptional: true }),
+    cancelledAt: field.dateTime({ isOptional: true }),
+    store: field.belongsTo("Store", ["storeId"], ["id"]),
+    items: field.hasMany("OrderItem"),
+    refunds: field.hasMany("Refund")
+  },
+  indexes: [
+    index.unique(["orderNumber"]),
+    index.on(["buyerId", "status"]),
+    index.on(["storeId", "status"]),
+    index.on(["status", "createdAt"]),
+    index.on(["paymentStatus"]),
+    index.on(["createdAt"])
+  ],
+  enums: [OrderStatusEnum, PaymentStatusEnum]
+});
+var OrderItemEntity = defineEntity({
+  name: "OrderItem",
+  description: "An item within an order.",
+  schema: "marketplace",
+  map: "order_item",
+  fields: {
+    id: field.id(),
+    orderId: field.foreignKey(),
+    productId: field.foreignKey(),
+    variantId: field.string({ isOptional: true }),
+    productName: field.string(),
+    variantName: field.string({ isOptional: true }),
+    sku: field.string({ isOptional: true }),
+    unitPrice: field.decimal(),
+    quantity: field.int(),
+    subtotal: field.decimal(),
+    quantityFulfilled: field.int({ default: 0 }),
+    quantityRefunded: field.int({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    order: field.belongsTo("Order", ["orderId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    product: field.belongsTo("Product", ["productId"], ["id"])
+  },
+  indexes: [index.on(["orderId"]), index.on(["productId"])]
+});
+var RefundEntity = defineEntity({
+  name: "Refund",
+  description: "A refund for an order.",
+  schema: "marketplace",
+  map: "refund",
+  fields: {
+    id: field.id(),
+    orderId: field.foreignKey(),
+    amount: field.decimal(),
+    currency: field.string(),
+    reason: field.string(),
+    notes: field.string({ isOptional: true }),
+    status: field.string({ default: '"PENDING"' }),
+    refundId: field.string({
+      isOptional: true,
+      description: "Payment provider refund ID"
+    }),
+    issuedBy: field.foreignKey({ description: "User who issued the refund" }),
+    createdAt: field.createdAt(),
+    processedAt: field.dateTime({ isOptional: true }),
+    order: field.belongsTo("Order", ["orderId"], ["id"]),
+    items: field.hasMany("RefundItem")
+  },
+  indexes: [index.on(["orderId"]), index.on(["status"])]
+});
+var RefundItemEntity = defineEntity({
+  name: "RefundItem",
+  description: "An item within a refund.",
+  schema: "marketplace",
+  map: "refund_item",
+  fields: {
+    id: field.id(),
+    refundId: field.foreignKey(),
+    orderItemId: field.foreignKey(),
+    quantity: field.int(),
+    amount: field.decimal(),
+    createdAt: field.createdAt(),
+    refund: field.belongsTo("Refund", ["refundId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    orderItem: field.belongsTo("OrderItem", ["orderItemId"], ["id"])
+  },
+  indexes: [index.on(["refundId"]), index.on(["orderItemId"])]
+});
+export {
+  RefundItemEntity,
+  RefundEntity,
+  PaymentStatusEnum,
+  OrderStatusEnum,
+  OrderItemEntity,
+  OrderEntity
+};

package/dist/browser/entities/payout.js

@@ -0,0 +1,142 @@
+// src/entities/payout.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var PayoutStatusEnum = defineEntityEnum({
+  name: "PayoutStatus",
+  values: ["PENDING", "PROCESSING", "PAID", "FAILED", "CANCELLED"],
+  schema: "marketplace",
+  description: "Status of a payout."
+});
+var PayoutScheduleEnum = defineEntityEnum({
+  name: "PayoutSchedule",
+  values: ["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY", "MANUAL"],
+  schema: "marketplace",
+  description: "Payout schedule frequency."
+});
+var PayoutEntity = defineEntity({
+  name: "Payout",
+  description: "A payout to a seller.",
+  schema: "marketplace",
+  map: "payout",
+  fields: {
+    id: field.id({ description: "Unique payout ID" }),
+    storeId: field.foreignKey(),
+    payoutNumber: field.string({ description: "Human-readable payout number" }),
+    status: field.enum("PayoutStatus", { default: "PENDING" }),
+    grossAmount: field.decimal({ description: "Total before fees" }),
+    platformFees: field.decimal({ description: "Platform fees deducted" }),
+    otherDeductions: field.decimal({ default: 0 }),
+    netAmount: field.decimal({ description: "Final payout amount" }),
+    currency: field.string({ default: '"USD"' }),
+    periodStart: field.dateTime({ description: "Start of payout period" }),
+    periodEnd: field.dateTime({ description: "End of payout period" }),
+    paymentMethod: field.string({ isOptional: true }),
+    paymentReference: field.string({ isOptional: true }),
+    bankAccountId: field.string({ isOptional: true }),
+    bankAccountLast4: field.string({ isOptional: true }),
+    notes: field.string({ isOptional: true }),
+    failureReason: field.string({ isOptional: true }),
+    orderCount: field.int({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    scheduledAt: field.dateTime({ isOptional: true }),
+    processedAt: field.dateTime({ isOptional: true }),
+    paidAt: field.dateTime({ isOptional: true }),
+    store: field.belongsTo("Store", ["storeId"], ["id"]),
+    items: field.hasMany("PayoutItem")
+  },
+  indexes: [
+    index.unique(["payoutNumber"]),
+    index.on(["storeId", "status"]),
+    index.on(["status", "scheduledAt"]),
+    index.on(["periodStart", "periodEnd"])
+  ],
+  enums: [PayoutStatusEnum]
+});
+var PayoutItemEntity = defineEntity({
+  name: "PayoutItem",
+  description: "An order included in a payout.",
+  schema: "marketplace",
+  map: "payout_item",
+  fields: {
+    id: field.id(),
+    payoutId: field.foreignKey(),
+    orderId: field.foreignKey(),
+    orderTotal: field.decimal(),
+    platformFee: field.decimal(),
+    netAmount: field.decimal(),
+    createdAt: field.createdAt(),
+    payout: field.belongsTo("Payout", ["payoutId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    order: field.belongsTo("Order", ["orderId"], ["id"])
+  },
+  indexes: [index.on(["payoutId"]), index.on(["orderId"])]
+});
+var BankAccountEntity = defineEntity({
+  name: "BankAccount",
+  description: "A bank account for receiving payouts.",
+  schema: "marketplace",
+  map: "bank_account",
+  fields: {
+    id: field.id(),
+    storeId: field.foreignKey(),
+    accountHolderName: field.string(),
+    accountType: field.string({ default: '"CHECKING"' }),
+    bankName: field.string({ isOptional: true }),
+    last4: field.string({ description: "Last 4 digits of account" }),
+    routingLast4: field.string({ isOptional: true }),
+    externalId: field.string({
+      isOptional: true,
+      description: "External provider account ID"
+    }),
+    isDefault: field.boolean({ default: false }),
+    isVerified: field.boolean({ default: false }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    verifiedAt: field.dateTime({ isOptional: true }),
+    store: field.belongsTo("Store", ["storeId"], ["id"])
+  },
+  indexes: [index.on(["storeId", "isDefault"]), index.on(["externalId"])]
+});
+var PayoutSettingsEntity = defineEntity({
+  name: "PayoutSettings",
+  description: "Payout configuration for a store.",
+  schema: "marketplace",
+  map: "payout_settings",
+  fields: {
+    id: field.id(),
+    storeId: field.foreignKey(),
+    schedule: field.enum("PayoutSchedule", { default: "WEEKLY" }),
+    dayOfWeek: field.int({
+      isOptional: true,
+      description: "Day for weekly/biweekly (0=Sunday)"
+    }),
+    dayOfMonth: field.int({
+      isOptional: true,
+      description: "Day for monthly (1-28)"
+    }),
+    minimumPayout: field.decimal({
+      default: 50,
+      description: "Minimum amount for payout"
+    }),
+    defaultBankAccountId: field.string({ isOptional: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    store: field.belongsTo("Store", ["storeId"], ["id"])
+  },
+  indexes: [index.unique(["storeId"])],
+  enums: [PayoutScheduleEnum]
+});
+export {
+  PayoutStatusEnum,
+  PayoutSettingsEntity,
+  PayoutScheduleEnum,
+  PayoutItemEntity,
+  PayoutEntity,
+  BankAccountEntity
+};

package/dist/browser/entities/product.js

@@ -0,0 +1,152 @@
+// src/entities/product.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var ProductStatusEnum = defineEntityEnum({
+  name: "ProductStatus",
+  values: [
+    "DRAFT",
+    "PENDING_REVIEW",
+    "ACTIVE",
+    "OUT_OF_STOCK",
+    "DISCONTINUED",
+    "REJECTED"
+  ],
+  schema: "marketplace",
+  description: "Status of a product listing."
+});
+var ProductTypeEnum = defineEntityEnum({
+  name: "ProductType",
+  values: ["PHYSICAL", "DIGITAL", "SERVICE", "SUBSCRIPTION"],
+  schema: "marketplace",
+  description: "Type of product."
+});
+var ProductEntity = defineEntity({
+  name: "Product",
+  description: "A product listing on the marketplace.",
+  schema: "marketplace",
+  map: "product",
+  fields: {
+    id: field.id({ description: "Unique product ID" }),
+    storeId: field.foreignKey(),
+    name: field.string({ description: "Product name" }),
+    slug: field.string({ description: "URL-friendly identifier" }),
+    description: field.string({ isOptional: true }),
+    shortDescription: field.string({ isOptional: true }),
+    status: field.enum("ProductStatus", { default: "DRAFT" }),
+    type: field.enum("ProductType", { default: "PHYSICAL" }),
+    price: field.decimal({ description: "Base price" }),
+    compareAtPrice: field.decimal({
+      isOptional: true,
+      description: "Original price for showing discounts"
+    }),
+    currency: field.string({ default: '"USD"' }),
+    sku: field.string({ isOptional: true }),
+    barcode: field.string({ isOptional: true }),
+    quantity: field.int({ default: 0 }),
+    trackInventory: field.boolean({ default: true }),
+    allowBackorder: field.boolean({ default: false }),
+    lowStockThreshold: field.int({ default: 5 }),
+    weight: field.decimal({ isOptional: true }),
+    weightUnit: field.string({ default: '"kg"' }),
+    categoryId: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+    primaryImageId: field.string({ isOptional: true }),
+    seoTitle: field.string({ isOptional: true }),
+    seoDescription: field.string({ isOptional: true }),
+    attributes: field.json({
+      isOptional: true,
+      description: "Custom product attributes"
+    }),
+    reviewCount: field.int({ default: 0 }),
+    averageRating: field.decimal({ default: 0 }),
+    totalSold: field.int({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    publishedAt: field.dateTime({ isOptional: true }),
+    store: field.belongsTo("Store", ["storeId"], ["id"]),
+    variants: field.hasMany("ProductVariant"),
+    orderItems: field.hasMany("OrderItem"),
+    reviews: field.hasMany("Review")
+  },
+  indexes: [
+    index.unique(["storeId", "slug"]),
+    index.on(["storeId", "status"]),
+    index.on(["status", "publishedAt"]),
+    index.on(["categoryId", "status"]),
+    index.on(["averageRating"]),
+    index.on(["totalSold"]),
+    index.on(["price"])
+  ],
+  enums: [ProductStatusEnum, ProductTypeEnum]
+});
+var ProductVariantEntity = defineEntity({
+  name: "ProductVariant",
+  description: "A variant of a product with specific options.",
+  schema: "marketplace",
+  map: "product_variant",
+  fields: {
+    id: field.id(),
+    productId: field.foreignKey(),
+    name: field.string({ description: 'Variant name (e.g., "Large / Blue")' }),
+    options: field.json({
+      description: 'Variant options (e.g., {size: "L", color: "Blue"})'
+    }),
+    price: field.decimal({ description: "Variant-specific price" }),
+    compareAtPrice: field.decimal({ isOptional: true }),
+    sku: field.string({ isOptional: true }),
+    barcode: field.string({ isOptional: true }),
+    quantity: field.int({ default: 0 }),
+    imageId: field.string({ isOptional: true }),
+    isActive: field.boolean({ default: true }),
+    position: field.int({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    product: field.belongsTo("Product", ["productId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index.on(["productId", "sku"]),
+    index.on(["productId", "position"]),
+    index.on(["barcode"])
+  ]
+});
+var CategoryEntity = defineEntity({
+  name: "Category",
+  description: "Product category for organization.",
+  schema: "marketplace",
+  map: "category",
+  fields: {
+    id: field.id(),
+    name: field.string(),
+    slug: field.string(),
+    description: field.string({ isOptional: true }),
+    parentId: field.string({ isOptional: true }),
+    path: field.string({ description: "Full path for hierarchical queries" }),
+    level: field.int({ default: 0 }),
+    position: field.int({ default: 0 }),
+    imageId: field.string({ isOptional: true }),
+    isActive: field.boolean({ default: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    parent: field.belongsTo("Category", ["parentId"], ["id"]),
+    children: field.hasMany("Category")
+  },
+  indexes: [
+    index.unique(["slug"]),
+    index.on(["parentId", "position"]),
+    index.on(["path"]),
+    index.on(["isActive"])
+  ]
+});
+export {
+  ProductVariantEntity,
+  ProductTypeEnum,
+  ProductStatusEnum,
+  ProductEntity,
+  CategoryEntity
+};

package/dist/browser/entities/review.js

@@ -0,0 +1,129 @@
+// src/entities/review.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var ReviewStatusEnum = defineEntityEnum({
+  name: "ReviewStatus",
+  values: ["PENDING", "APPROVED", "REJECTED", "FLAGGED"],
+  schema: "marketplace",
+  description: "Status of a review."
+});
+var ReviewTypeEnum = defineEntityEnum({
+  name: "ReviewType",
+  values: ["PRODUCT", "STORE", "ORDER"],
+  schema: "marketplace",
+  description: "Type of review."
+});
+var ReviewEntity = defineEntity({
+  name: "Review",
+  description: "A customer review on the marketplace.",
+  schema: "marketplace",
+  map: "review",
+  fields: {
+    id: field.id({ description: "Unique review ID" }),
+    type: field.enum("ReviewType", { default: "PRODUCT" }),
+    productId: field.string({ isOptional: true }),
+    storeId: field.string({ isOptional: true }),
+    orderId: field.string({ isOptional: true }),
+    orderItemId: field.string({ isOptional: true }),
+    authorId: field.foreignKey({ description: "Reviewer user ID" }),
+    rating: field.int({ description: "Rating 1-5" }),
+    title: field.string({ isOptional: true }),
+    content: field.string({ isOptional: true }),
+    isVerifiedPurchase: field.boolean({ default: false }),
+    status: field.enum("ReviewStatus", { default: "PENDING" }),
+    hasMedia: field.boolean({ default: false }),
+    helpfulCount: field.int({ default: 0 }),
+    notHelpfulCount: field.int({ default: 0 }),
+    moderatedBy: field.string({ isOptional: true }),
+    moderatedAt: field.dateTime({ isOptional: true }),
+    moderationNote: field.string({ isOptional: true }),
+    hasResponse: field.boolean({ default: false }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    product: field.belongsTo("Product", ["productId"], ["id"]),
+    store: field.belongsTo("Store", ["storeId"], ["id"]),
+    responses: field.hasMany("ReviewResponse"),
+    votes: field.hasMany("ReviewVote")
+  },
+  indexes: [
+    index.on(["productId", "status", "createdAt"]),
+    index.on(["storeId", "status", "createdAt"]),
+    index.on(["authorId"]),
+    index.on(["orderId"]),
+    index.on(["status"]),
+    index.on(["rating"]),
+    index.on(["isVerifiedPurchase", "status"])
+  ],
+  enums: [ReviewStatusEnum, ReviewTypeEnum]
+});
+var ReviewResponseEntity = defineEntity({
+  name: "ReviewResponse",
+  description: "A seller response to a review.",
+  schema: "marketplace",
+  map: "review_response",
+  fields: {
+    id: field.id(),
+    reviewId: field.foreignKey(),
+    authorId: field.foreignKey(),
+    content: field.string(),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    review: field.belongsTo("Review", ["reviewId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.on(["reviewId"]), index.on(["authorId"])]
+});
+var ReviewVoteEntity = defineEntity({
+  name: "ReviewVote",
+  description: "A helpfulness vote on a review.",
+  schema: "marketplace",
+  map: "review_vote",
+  fields: {
+    id: field.id(),
+    reviewId: field.foreignKey(),
+    userId: field.foreignKey(),
+    isHelpful: field.boolean(),
+    createdAt: field.createdAt(),
+    review: field.belongsTo("Review", ["reviewId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.unique(["reviewId", "userId"]), index.on(["userId"])]
+});
+var ReviewReportEntity = defineEntity({
+  name: "ReviewReport",
+  description: "A report/flag on a review.",
+  schema: "marketplace",
+  map: "review_report",
+  fields: {
+    id: field.id(),
+    reviewId: field.foreignKey(),
+    reporterId: field.foreignKey(),
+    reason: field.string({ description: "Report reason category" }),
+    details: field.string({ isOptional: true }),
+    status: field.string({ default: '"PENDING"' }),
+    resolvedBy: field.string({ isOptional: true }),
+    resolvedAt: field.dateTime({ isOptional: true }),
+    resolution: field.string({ isOptional: true }),
+    createdAt: field.createdAt(),
+    review: field.belongsTo("Review", ["reviewId"], ["id"])
+  },
+  indexes: [
+    index.on(["reviewId"]),
+    index.on(["status"]),
+    index.on(["reporterId"])
+  ]
+});
+export {
+  ReviewVoteEntity,
+  ReviewTypeEnum,
+  ReviewStatusEnum,
+  ReviewResponseEntity,
+  ReviewReportEntity,
+  ReviewEntity
+};

package/dist/browser/entities/store.js

@@ -0,0 +1,97 @@
+// src/entities/store.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var StoreStatusEnum = defineEntityEnum({
+  name: "StoreStatus",
+  values: ["PENDING", "ACTIVE", "SUSPENDED", "CLOSED"],
+  schema: "marketplace",
+  description: "Status of a store."
+});
+var StoreTypeEnum = defineEntityEnum({
+  name: "StoreType",
+  values: ["INDIVIDUAL", "BUSINESS", "ENTERPRISE"],
+  schema: "marketplace",
+  description: "Type of store account."
+});
+var StoreEntity = defineEntity({
+  name: "Store",
+  description: "A seller storefront on the marketplace.",
+  schema: "marketplace",
+  map: "store",
+  fields: {
+    id: field.id({ description: "Unique store ID" }),
+    name: field.string({ description: "Store display name" }),
+    slug: field.string({ description: "URL-friendly identifier" }),
+    description: field.string({ isOptional: true }),
+    status: field.enum("StoreStatus", { default: "PENDING" }),
+    type: field.enum("StoreType", { default: "INDIVIDUAL" }),
+    ownerId: field.foreignKey({ description: "Store owner user ID" }),
+    organizationId: field.foreignKey({ isOptional: true }),
+    logoFileId: field.string({
+      isOptional: true,
+      description: "Logo file reference"
+    }),
+    bannerFileId: field.string({
+      isOptional: true,
+      description: "Banner file reference"
+    }),
+    email: field.string({ isOptional: true }),
+    phone: field.string({ isOptional: true }),
+    website: field.string({ isOptional: true }),
+    country: field.string({ isOptional: true }),
+    currency: field.string({ default: '"USD"' }),
+    timezone: field.string({ isOptional: true }),
+    commissionRate: field.decimal({
+      default: 0.1,
+      description: "Platform commission rate (e.g., 0.1 = 10%)"
+    }),
+    isVerified: field.boolean({ default: false }),
+    verifiedAt: field.dateTime({ isOptional: true }),
+    settings: field.json({ isOptional: true }),
+    metadata: field.json({ isOptional: true }),
+    totalProducts: field.int({ default: 0 }),
+    totalOrders: field.int({ default: 0 }),
+    totalRevenue: field.decimal({ default: 0 }),
+    averageRating: field.decimal({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    products: field.hasMany("Product"),
+    orders: field.hasMany("Order"),
+    payouts: field.hasMany("Payout")
+  },
+  indexes: [
+    index.unique(["slug"]),
+    index.on(["ownerId"]),
+    index.on(["status"]),
+    index.on(["country", "status"]),
+    index.on(["averageRating"])
+  ],
+  enums: [StoreStatusEnum, StoreTypeEnum]
+});
+var StoreCategoryEntity = defineEntity({
+  name: "StoreCategory",
+  description: "Category assignment for stores.",
+  schema: "marketplace",
+  map: "store_category",
+  fields: {
+    id: field.id(),
+    storeId: field.foreignKey(),
+    categoryId: field.foreignKey(),
+    isPrimary: field.boolean({ default: false }),
+    createdAt: field.createdAt(),
+    store: field.belongsTo("Store", ["storeId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.unique(["storeId", "categoryId"]), index.on(["categoryId"])]
+});
+export {
+  StoreTypeEnum,
+  StoreStatusEnum,
+  StoreEntity,
+  StoreCategoryEntity
+};