@contractspec/example.marketplace 1.57.0 → 1.58.0

package/dist/browser/entities/index.js

@@ -0,0 +1,721 @@
+// 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"])]
+});
+
+// src/entities/product.ts
+import {
+  defineEntity as defineEntity2,
+  defineEntityEnum as defineEntityEnum2,
+  field as field2,
+  index as index2
+} from "@contractspec/lib.schema";
+var ProductStatusEnum = defineEntityEnum2({
+  name: "ProductStatus",
+  values: [
+    "DRAFT",
+    "PENDING_REVIEW",
+    "ACTIVE",
+    "OUT_OF_STOCK",
+    "DISCONTINUED",
+    "REJECTED"
+  ],
+  schema: "marketplace",
+  description: "Status of a product listing."
+});
+var ProductTypeEnum = defineEntityEnum2({
+  name: "ProductType",
+  values: ["PHYSICAL", "DIGITAL", "SERVICE", "SUBSCRIPTION"],
+  schema: "marketplace",
+  description: "Type of product."
+});
+var ProductEntity = defineEntity2({
+  name: "Product",
+  description: "A product listing on the marketplace.",
+  schema: "marketplace",
+  map: "product",
+  fields: {
+    id: field2.id({ description: "Unique product ID" }),
+    storeId: field2.foreignKey(),
+    name: field2.string({ description: "Product name" }),
+    slug: field2.string({ description: "URL-friendly identifier" }),
+    description: field2.string({ isOptional: true }),
+    shortDescription: field2.string({ isOptional: true }),
+    status: field2.enum("ProductStatus", { default: "DRAFT" }),
+    type: field2.enum("ProductType", { default: "PHYSICAL" }),
+    price: field2.decimal({ description: "Base price" }),
+    compareAtPrice: field2.decimal({
+      isOptional: true,
+      description: "Original price for showing discounts"
+    }),
+    currency: field2.string({ default: '"USD"' }),
+    sku: field2.string({ isOptional: true }),
+    barcode: field2.string({ isOptional: true }),
+    quantity: field2.int({ default: 0 }),
+    trackInventory: field2.boolean({ default: true }),
+    allowBackorder: field2.boolean({ default: false }),
+    lowStockThreshold: field2.int({ default: 5 }),
+    weight: field2.decimal({ isOptional: true }),
+    weightUnit: field2.string({ default: '"kg"' }),
+    categoryId: field2.string({ isOptional: true }),
+    tags: field2.string({ isArray: true }),
+    primaryImageId: field2.string({ isOptional: true }),
+    seoTitle: field2.string({ isOptional: true }),
+    seoDescription: field2.string({ isOptional: true }),
+    attributes: field2.json({
+      isOptional: true,
+      description: "Custom product attributes"
+    }),
+    reviewCount: field2.int({ default: 0 }),
+    averageRating: field2.decimal({ default: 0 }),
+    totalSold: field2.int({ default: 0 }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    publishedAt: field2.dateTime({ isOptional: true }),
+    store: field2.belongsTo("Store", ["storeId"], ["id"]),
+    variants: field2.hasMany("ProductVariant"),
+    orderItems: field2.hasMany("OrderItem"),
+    reviews: field2.hasMany("Review")
+  },
+  indexes: [
+    index2.unique(["storeId", "slug"]),
+    index2.on(["storeId", "status"]),
+    index2.on(["status", "publishedAt"]),
+    index2.on(["categoryId", "status"]),
+    index2.on(["averageRating"]),
+    index2.on(["totalSold"]),
+    index2.on(["price"])
+  ],
+  enums: [ProductStatusEnum, ProductTypeEnum]
+});
+var ProductVariantEntity = defineEntity2({
+  name: "ProductVariant",
+  description: "A variant of a product with specific options.",
+  schema: "marketplace",
+  map: "product_variant",
+  fields: {
+    id: field2.id(),
+    productId: field2.foreignKey(),
+    name: field2.string({ description: 'Variant name (e.g., "Large / Blue")' }),
+    options: field2.json({
+      description: 'Variant options (e.g., {size: "L", color: "Blue"})'
+    }),
+    price: field2.decimal({ description: "Variant-specific price" }),
+    compareAtPrice: field2.decimal({ isOptional: true }),
+    sku: field2.string({ isOptional: true }),
+    barcode: field2.string({ isOptional: true }),
+    quantity: field2.int({ default: 0 }),
+    imageId: field2.string({ isOptional: true }),
+    isActive: field2.boolean({ default: true }),
+    position: field2.int({ default: 0 }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    product: field2.belongsTo("Product", ["productId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index2.on(["productId", "sku"]),
+    index2.on(["productId", "position"]),
+    index2.on(["barcode"])
+  ]
+});
+var CategoryEntity = defineEntity2({
+  name: "Category",
+  description: "Product category for organization.",
+  schema: "marketplace",
+  map: "category",
+  fields: {
+    id: field2.id(),
+    name: field2.string(),
+    slug: field2.string(),
+    description: field2.string({ isOptional: true }),
+    parentId: field2.string({ isOptional: true }),
+    path: field2.string({ description: "Full path for hierarchical queries" }),
+    level: field2.int({ default: 0 }),
+    position: field2.int({ default: 0 }),
+    imageId: field2.string({ isOptional: true }),
+    isActive: field2.boolean({ default: true }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    parent: field2.belongsTo("Category", ["parentId"], ["id"]),
+    children: field2.hasMany("Category")
+  },
+  indexes: [
+    index2.unique(["slug"]),
+    index2.on(["parentId", "position"]),
+    index2.on(["path"]),
+    index2.on(["isActive"])
+  ]
+});
+
+// src/entities/order.ts
+import {
+  defineEntity as defineEntity3,
+  defineEntityEnum as defineEntityEnum3,
+  field as field3,
+  index as index3
+} from "@contractspec/lib.schema";
+var OrderStatusEnum = defineEntityEnum3({
+  name: "OrderStatus",
+  values: [
+    "PENDING",
+    "PAID",
+    "PROCESSING",
+    "SHIPPED",
+    "DELIVERED",
+    "COMPLETED",
+    "CANCELLED",
+    "REFUNDED",
+    "PARTIALLY_REFUNDED",
+    "DISPUTED"
+  ],
+  schema: "marketplace",
+  description: "Status of an order."
+});
+var PaymentStatusEnum = defineEntityEnum3({
+  name: "PaymentStatus",
+  values: [
+    "PENDING",
+    "AUTHORIZED",
+    "CAPTURED",
+    "FAILED",
+    "REFUNDED",
+    "VOIDED"
+  ],
+  schema: "marketplace",
+  description: "Status of payment."
+});
+var OrderEntity = defineEntity3({
+  name: "Order",
+  description: "A purchase order on the marketplace.",
+  schema: "marketplace",
+  map: "order",
+  fields: {
+    id: field3.id({ description: "Unique order ID" }),
+    orderNumber: field3.string({ description: "Human-readable order number" }),
+    buyerId: field3.foreignKey({ description: "Buyer user ID" }),
+    storeId: field3.foreignKey({ description: "Seller store ID" }),
+    status: field3.enum("OrderStatus", { default: "PENDING" }),
+    paymentStatus: field3.enum("PaymentStatus", { default: "PENDING" }),
+    subtotal: field3.decimal({ description: "Sum of item prices" }),
+    shippingTotal: field3.decimal({ default: 0 }),
+    taxTotal: field3.decimal({ default: 0 }),
+    discountTotal: field3.decimal({ default: 0 }),
+    total: field3.decimal({ description: "Final total" }),
+    currency: field3.string({ default: '"USD"' }),
+    platformFee: field3.decimal({ description: "Platform commission amount" }),
+    sellerPayout: field3.decimal({ description: "Amount due to seller" }),
+    shippingAddress: field3.json({ isOptional: true }),
+    billingAddress: field3.json({ isOptional: true }),
+    shippingMethod: field3.string({ isOptional: true }),
+    trackingNumber: field3.string({ isOptional: true }),
+    trackingUrl: field3.string({ isOptional: true }),
+    paymentMethod: field3.string({ isOptional: true }),
+    paymentIntentId: field3.string({ isOptional: true }),
+    buyerNote: field3.string({ isOptional: true }),
+    sellerNote: field3.string({ isOptional: true }),
+    internalNote: field3.string({ isOptional: true }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    paidAt: field3.dateTime({ isOptional: true }),
+    shippedAt: field3.dateTime({ isOptional: true }),
+    deliveredAt: field3.dateTime({ isOptional: true }),
+    completedAt: field3.dateTime({ isOptional: true }),
+    cancelledAt: field3.dateTime({ isOptional: true }),
+    store: field3.belongsTo("Store", ["storeId"], ["id"]),
+    items: field3.hasMany("OrderItem"),
+    refunds: field3.hasMany("Refund")
+  },
+  indexes: [
+    index3.unique(["orderNumber"]),
+    index3.on(["buyerId", "status"]),
+    index3.on(["storeId", "status"]),
+    index3.on(["status", "createdAt"]),
+    index3.on(["paymentStatus"]),
+    index3.on(["createdAt"])
+  ],
+  enums: [OrderStatusEnum, PaymentStatusEnum]
+});
+var OrderItemEntity = defineEntity3({
+  name: "OrderItem",
+  description: "An item within an order.",
+  schema: "marketplace",
+  map: "order_item",
+  fields: {
+    id: field3.id(),
+    orderId: field3.foreignKey(),
+    productId: field3.foreignKey(),
+    variantId: field3.string({ isOptional: true }),
+    productName: field3.string(),
+    variantName: field3.string({ isOptional: true }),
+    sku: field3.string({ isOptional: true }),
+    unitPrice: field3.decimal(),
+    quantity: field3.int(),
+    subtotal: field3.decimal(),
+    quantityFulfilled: field3.int({ default: 0 }),
+    quantityRefunded: field3.int({ default: 0 }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    order: field3.belongsTo("Order", ["orderId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    product: field3.belongsTo("Product", ["productId"], ["id"])
+  },
+  indexes: [index3.on(["orderId"]), index3.on(["productId"])]
+});
+var RefundEntity = defineEntity3({
+  name: "Refund",
+  description: "A refund for an order.",
+  schema: "marketplace",
+  map: "refund",
+  fields: {
+    id: field3.id(),
+    orderId: field3.foreignKey(),
+    amount: field3.decimal(),
+    currency: field3.string(),
+    reason: field3.string(),
+    notes: field3.string({ isOptional: true }),
+    status: field3.string({ default: '"PENDING"' }),
+    refundId: field3.string({
+      isOptional: true,
+      description: "Payment provider refund ID"
+    }),
+    issuedBy: field3.foreignKey({ description: "User who issued the refund" }),
+    createdAt: field3.createdAt(),
+    processedAt: field3.dateTime({ isOptional: true }),
+    order: field3.belongsTo("Order", ["orderId"], ["id"]),
+    items: field3.hasMany("RefundItem")
+  },
+  indexes: [index3.on(["orderId"]), index3.on(["status"])]
+});
+var RefundItemEntity = defineEntity3({
+  name: "RefundItem",
+  description: "An item within a refund.",
+  schema: "marketplace",
+  map: "refund_item",
+  fields: {
+    id: field3.id(),
+    refundId: field3.foreignKey(),
+    orderItemId: field3.foreignKey(),
+    quantity: field3.int(),
+    amount: field3.decimal(),
+    createdAt: field3.createdAt(),
+    refund: field3.belongsTo("Refund", ["refundId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    orderItem: field3.belongsTo("OrderItem", ["orderItemId"], ["id"])
+  },
+  indexes: [index3.on(["refundId"]), index3.on(["orderItemId"])]
+});
+
+// src/entities/payout.ts
+import {
+  defineEntity as defineEntity4,
+  defineEntityEnum as defineEntityEnum4,
+  field as field4,
+  index as index4
+} from "@contractspec/lib.schema";
+var PayoutStatusEnum = defineEntityEnum4({
+  name: "PayoutStatus",
+  values: ["PENDING", "PROCESSING", "PAID", "FAILED", "CANCELLED"],
+  schema: "marketplace",
+  description: "Status of a payout."
+});
+var PayoutScheduleEnum = defineEntityEnum4({
+  name: "PayoutSchedule",
+  values: ["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY", "MANUAL"],
+  schema: "marketplace",
+  description: "Payout schedule frequency."
+});
+var PayoutEntity = defineEntity4({
+  name: "Payout",
+  description: "A payout to a seller.",
+  schema: "marketplace",
+  map: "payout",
+  fields: {
+    id: field4.id({ description: "Unique payout ID" }),
+    storeId: field4.foreignKey(),
+    payoutNumber: field4.string({ description: "Human-readable payout number" }),
+    status: field4.enum("PayoutStatus", { default: "PENDING" }),
+    grossAmount: field4.decimal({ description: "Total before fees" }),
+    platformFees: field4.decimal({ description: "Platform fees deducted" }),
+    otherDeductions: field4.decimal({ default: 0 }),
+    netAmount: field4.decimal({ description: "Final payout amount" }),
+    currency: field4.string({ default: '"USD"' }),
+    periodStart: field4.dateTime({ description: "Start of payout period" }),
+    periodEnd: field4.dateTime({ description: "End of payout period" }),
+    paymentMethod: field4.string({ isOptional: true }),
+    paymentReference: field4.string({ isOptional: true }),
+    bankAccountId: field4.string({ isOptional: true }),
+    bankAccountLast4: field4.string({ isOptional: true }),
+    notes: field4.string({ isOptional: true }),
+    failureReason: field4.string({ isOptional: true }),
+    orderCount: field4.int({ default: 0 }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    scheduledAt: field4.dateTime({ isOptional: true }),
+    processedAt: field4.dateTime({ isOptional: true }),
+    paidAt: field4.dateTime({ isOptional: true }),
+    store: field4.belongsTo("Store", ["storeId"], ["id"]),
+    items: field4.hasMany("PayoutItem")
+  },
+  indexes: [
+    index4.unique(["payoutNumber"]),
+    index4.on(["storeId", "status"]),
+    index4.on(["status", "scheduledAt"]),
+    index4.on(["periodStart", "periodEnd"])
+  ],
+  enums: [PayoutStatusEnum]
+});
+var PayoutItemEntity = defineEntity4({
+  name: "PayoutItem",
+  description: "An order included in a payout.",
+  schema: "marketplace",
+  map: "payout_item",
+  fields: {
+    id: field4.id(),
+    payoutId: field4.foreignKey(),
+    orderId: field4.foreignKey(),
+    orderTotal: field4.decimal(),
+    platformFee: field4.decimal(),
+    netAmount: field4.decimal(),
+    createdAt: field4.createdAt(),
+    payout: field4.belongsTo("Payout", ["payoutId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    order: field4.belongsTo("Order", ["orderId"], ["id"])
+  },
+  indexes: [index4.on(["payoutId"]), index4.on(["orderId"])]
+});
+var BankAccountEntity = defineEntity4({
+  name: "BankAccount",
+  description: "A bank account for receiving payouts.",
+  schema: "marketplace",
+  map: "bank_account",
+  fields: {
+    id: field4.id(),
+    storeId: field4.foreignKey(),
+    accountHolderName: field4.string(),
+    accountType: field4.string({ default: '"CHECKING"' }),
+    bankName: field4.string({ isOptional: true }),
+    last4: field4.string({ description: "Last 4 digits of account" }),
+    routingLast4: field4.string({ isOptional: true }),
+    externalId: field4.string({
+      isOptional: true,
+      description: "External provider account ID"
+    }),
+    isDefault: field4.boolean({ default: false }),
+    isVerified: field4.boolean({ default: false }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    verifiedAt: field4.dateTime({ isOptional: true }),
+    store: field4.belongsTo("Store", ["storeId"], ["id"])
+  },
+  indexes: [index4.on(["storeId", "isDefault"]), index4.on(["externalId"])]
+});
+var PayoutSettingsEntity = defineEntity4({
+  name: "PayoutSettings",
+  description: "Payout configuration for a store.",
+  schema: "marketplace",
+  map: "payout_settings",
+  fields: {
+    id: field4.id(),
+    storeId: field4.foreignKey(),
+    schedule: field4.enum("PayoutSchedule", { default: "WEEKLY" }),
+    dayOfWeek: field4.int({
+      isOptional: true,
+      description: "Day for weekly/biweekly (0=Sunday)"
+    }),
+    dayOfMonth: field4.int({
+      isOptional: true,
+      description: "Day for monthly (1-28)"
+    }),
+    minimumPayout: field4.decimal({
+      default: 50,
+      description: "Minimum amount for payout"
+    }),
+    defaultBankAccountId: field4.string({ isOptional: true }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    store: field4.belongsTo("Store", ["storeId"], ["id"])
+  },
+  indexes: [index4.unique(["storeId"])],
+  enums: [PayoutScheduleEnum]
+});
+
+// src/entities/review.ts
+import {
+  defineEntity as defineEntity5,
+  defineEntityEnum as defineEntityEnum5,
+  field as field5,
+  index as index5
+} from "@contractspec/lib.schema";
+var ReviewStatusEnum = defineEntityEnum5({
+  name: "ReviewStatus",
+  values: ["PENDING", "APPROVED", "REJECTED", "FLAGGED"],
+  schema: "marketplace",
+  description: "Status of a review."
+});
+var ReviewTypeEnum = defineEntityEnum5({
+  name: "ReviewType",
+  values: ["PRODUCT", "STORE", "ORDER"],
+  schema: "marketplace",
+  description: "Type of review."
+});
+var ReviewEntity = defineEntity5({
+  name: "Review",
+  description: "A customer review on the marketplace.",
+  schema: "marketplace",
+  map: "review",
+  fields: {
+    id: field5.id({ description: "Unique review ID" }),
+    type: field5.enum("ReviewType", { default: "PRODUCT" }),
+    productId: field5.string({ isOptional: true }),
+    storeId: field5.string({ isOptional: true }),
+    orderId: field5.string({ isOptional: true }),
+    orderItemId: field5.string({ isOptional: true }),
+    authorId: field5.foreignKey({ description: "Reviewer user ID" }),
+    rating: field5.int({ description: "Rating 1-5" }),
+    title: field5.string({ isOptional: true }),
+    content: field5.string({ isOptional: true }),
+    isVerifiedPurchase: field5.boolean({ default: false }),
+    status: field5.enum("ReviewStatus", { default: "PENDING" }),
+    hasMedia: field5.boolean({ default: false }),
+    helpfulCount: field5.int({ default: 0 }),
+    notHelpfulCount: field5.int({ default: 0 }),
+    moderatedBy: field5.string({ isOptional: true }),
+    moderatedAt: field5.dateTime({ isOptional: true }),
+    moderationNote: field5.string({ isOptional: true }),
+    hasResponse: field5.boolean({ default: false }),
+    createdAt: field5.createdAt(),
+    updatedAt: field5.updatedAt(),
+    product: field5.belongsTo("Product", ["productId"], ["id"]),
+    store: field5.belongsTo("Store", ["storeId"], ["id"]),
+    responses: field5.hasMany("ReviewResponse"),
+    votes: field5.hasMany("ReviewVote")
+  },
+  indexes: [
+    index5.on(["productId", "status", "createdAt"]),
+    index5.on(["storeId", "status", "createdAt"]),
+    index5.on(["authorId"]),
+    index5.on(["orderId"]),
+    index5.on(["status"]),
+    index5.on(["rating"]),
+    index5.on(["isVerifiedPurchase", "status"])
+  ],
+  enums: [ReviewStatusEnum, ReviewTypeEnum]
+});
+var ReviewResponseEntity = defineEntity5({
+  name: "ReviewResponse",
+  description: "A seller response to a review.",
+  schema: "marketplace",
+  map: "review_response",
+  fields: {
+    id: field5.id(),
+    reviewId: field5.foreignKey(),
+    authorId: field5.foreignKey(),
+    content: field5.string(),
+    createdAt: field5.createdAt(),
+    updatedAt: field5.updatedAt(),
+    review: field5.belongsTo("Review", ["reviewId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index5.on(["reviewId"]), index5.on(["authorId"])]
+});
+var ReviewVoteEntity = defineEntity5({
+  name: "ReviewVote",
+  description: "A helpfulness vote on a review.",
+  schema: "marketplace",
+  map: "review_vote",
+  fields: {
+    id: field5.id(),
+    reviewId: field5.foreignKey(),
+    userId: field5.foreignKey(),
+    isHelpful: field5.boolean(),
+    createdAt: field5.createdAt(),
+    review: field5.belongsTo("Review", ["reviewId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index5.unique(["reviewId", "userId"]), index5.on(["userId"])]
+});
+var ReviewReportEntity = defineEntity5({
+  name: "ReviewReport",
+  description: "A report/flag on a review.",
+  schema: "marketplace",
+  map: "review_report",
+  fields: {
+    id: field5.id(),
+    reviewId: field5.foreignKey(),
+    reporterId: field5.foreignKey(),
+    reason: field5.string({ description: "Report reason category" }),
+    details: field5.string({ isOptional: true }),
+    status: field5.string({ default: '"PENDING"' }),
+    resolvedBy: field5.string({ isOptional: true }),
+    resolvedAt: field5.dateTime({ isOptional: true }),
+    resolution: field5.string({ isOptional: true }),
+    createdAt: field5.createdAt(),
+    review: field5.belongsTo("Review", ["reviewId"], ["id"])
+  },
+  indexes: [
+    index5.on(["reviewId"]),
+    index5.on(["status"]),
+    index5.on(["reporterId"])
+  ]
+});
+// src/entities/index.ts
+var marketplaceEntities = [
+  StoreEntity,
+  StoreCategoryEntity,
+  ProductEntity,
+  ProductVariantEntity,
+  CategoryEntity,
+  OrderEntity,
+  OrderItemEntity,
+  RefundEntity,
+  RefundItemEntity,
+  PayoutEntity,
+  PayoutItemEntity,
+  BankAccountEntity,
+  PayoutSettingsEntity,
+  ReviewEntity,
+  ReviewResponseEntity,
+  ReviewVoteEntity,
+  ReviewReportEntity
+];
+var marketplaceSchemaContribution = {
+  moduleId: "@contractspec/example.marketplace",
+  entities: marketplaceEntities,
+  enums: [
+    StoreStatusEnum,
+    StoreTypeEnum,
+    ProductStatusEnum,
+    ProductTypeEnum,
+    OrderStatusEnum,
+    PaymentStatusEnum,
+    PayoutStatusEnum,
+    PayoutScheduleEnum,
+    ReviewStatusEnum,
+    ReviewTypeEnum
+  ]
+};
+export {
+  marketplaceSchemaContribution,
+  marketplaceEntities,
+  StoreTypeEnum,
+  StoreStatusEnum,
+  StoreEntity,
+  StoreCategoryEntity,
+  ReviewVoteEntity,
+  ReviewTypeEnum,
+  ReviewStatusEnum,
+  ReviewResponseEntity,
+  ReviewReportEntity,
+  ReviewEntity,
+  RefundItemEntity,
+  RefundEntity,
+  ProductVariantEntity,
+  ProductTypeEnum,
+  ProductStatusEnum,
+  ProductEntity,
+  PayoutStatusEnum,
+  PayoutSettingsEntity,
+  PayoutScheduleEnum,
+  PayoutItemEntity,
+  PayoutEntity,
+  PaymentStatusEnum,
+  OrderStatusEnum,
+  OrderItemEntity,
+  OrderEntity,
+  CategoryEntity,
+  BankAccountEntity
+};