schema.prisma

generator client {
  provider            = "prisma-client"
  output              = "../src/generated/prisma"
  moduleFormat        = "cjs"
  importFileExtension = ""
}

datasource db {
  provider = "postgresql"
}

enum AddressType {
  HOME
  WORK
  OTHER
}

enum VendorStatus {
  REGISTERED
  KYC_PENDING
  UNDER_REVIEW
  APPROVED
  ACTIVE
  REJECTED
  SUSPENDED
  BLOCKED
}

enum IamProvisioningStatus {
  NOT_PROVISIONED
  PENDING
  PROVISIONED
  FAILED
}

enum IamProvisioningOperationStatus {
  PENDING
  PROCESSING
  COMPLETED
  FAILED
}

enum IamProvisioningOperationType {
  PROVISION_VENDOR
  ASSIGN_VENDOR_STAFF
  REVOKE_VENDOR_STAFF
  ASSIGN_PLATFORM_CAPABILITIES
}

enum VendorVerificationStatus {
  DRAFT
  SUBMITTED
  UNDER_REVIEW
  APPROVED
  REJECTED
}

enum VendorDocumentType {
  BUSINESS_REGISTRATION
  TAX_REGISTRATION
  IDENTITY
  ADDRESS_PROOF
  BANK_PROOF
  OTHER
}

enum CategoryStatus {
  ACTIVE
  INACTIVE
  ARCHIVED
}

enum AttributeType {
  TEXT
  NUMBER
  BOOLEAN
  SELECT
  MULTI_SELECT
  COLOR
}

enum ProductStatus {
  DRAFT
  SUBMITTED
  UNDER_REVIEW
  CHANGES_REQUIRED
  APPROVED
  PUBLISHED
  UNPUBLISHED
  REJECTED
  SUSPENDED
  ARCHIVED
}

enum ProductVariantStatus {
  ACTIVE
  INACTIVE
  ARCHIVED
}

enum InventoryReservationStatus {
  HELD
  COMMITTED
  RELEASED
  EXPIRED
}

enum InventoryMovementType {
  INITIAL_STOCK
  ADJUSTMENT
  RESERVATION_CREATED
  RESERVATION_RELEASED
  SALE_COMMITTED
  RETURN_RESTOCKED
  DAMAGE
  CORRECTION
}

enum CartStatus {
  ACTIVE
  CONVERTED
  ABANDONED
}

enum PromotionType {
  PERCENTAGE
  FIXED_AMOUNT
  FREE_SHIPPING
}

enum PromotionFunding {
  MARKETPLACE
  VENDOR
  SHARED
}

enum PromotionStatus {
  DRAFT
  ACTIVE
  PAUSED
  EXPIRED
  ARCHIVED
}

enum CheckoutStatus {
  CREATED
  INVENTORY_RESERVED
  PAYMENT_PENDING
  COMPLETED
  EXPIRED
  CANCELLED
  FAILED
}

enum MarketplaceOrderStatus {
  CREATED
  PAYMENT_PENDING
  CONFIRMED
  PROCESSING
  PARTIALLY_FULFILLED
  FULFILLED
  COMPLETED
  CANCELLED
}

enum VendorOrderStatus {
  PENDING
  ACCEPTED
  PROCESSING
  READY_TO_SHIP
  SHIPPED
  OUT_FOR_DELIVERY
  DELIVERED
  CANCELLED
  RETURN_REQUESTED
  RETURNED
}

enum PaymentStatus {
  CREATED
  PENDING
  AUTHORIZED
  CAPTURED
  FAILED
  CANCELLED
  PARTIALLY_REFUNDED
  REFUNDED
}

enum PaymentAttemptStatus {
  CREATED
  PENDING
  SUCCEEDED
  FAILED
  CANCELLED
}

enum WebhookProcessingStatus {
  RECEIVED
  PROCESSING
  PROCESSED
  FAILED
  IGNORED
}

enum IdempotencyStatus {
  PROCESSING
  COMPLETED
  FAILED
}

enum CommissionRuleScope {
  DEFAULT
  VENDOR
  CATEGORY
  VENDOR_CATEGORY
}

enum VendorLedgerEntryType {
  ORDER_EARNING
  MARKETPLACE_COMMISSION
  PAYMENT_FEE
  SHIPPING_CHARGE
  DISCOUNT_ADJUSTMENT
  REFUND
  REVERSAL
  MANUAL_ADJUSTMENT
  SETTLEMENT
  PAYOUT
}

enum LedgerDirection {
  CREDIT
  DEBIT
}

enum SettlementStatus {
  PENDING
  ELIGIBLE
  PROCESSING
  SETTLED
  FAILED
  CANCELLED
}

enum FulfillmentStatus {
  PENDING
  ACCEPTED
  PACKING
  PACKED
  READY_TO_SHIP
  HANDED_OVER
  CANCELLED
}

enum ShipmentType {
  FORWARD
  RETURN
}

enum ShipmentStatus {
  CREATED
  AWB_ASSIGNED
  PICKUP_SCHEDULED
  PICKED_UP
  IN_TRANSIT
  OUT_FOR_DELIVERY
  DELIVERED
  DELIVERY_FAILED
  RETURN_TO_ORIGIN
  CANCELLED
}

enum ReturnRequestStatus {
  REQUESTED
  UNDER_REVIEW
  APPROVED
  REJECTED
  PICKUP_SCHEDULED
  IN_TRANSIT
  RECEIVED
  INSPECTED
  COMPLETED
  CANCELLED
}

enum ReturnItemStatus {
  REQUESTED
  APPROVED
  REJECTED
  IN_TRANSIT
  RECEIVED
  INSPECTED
  REFUNDED
}

enum RefundStatus {
  REQUESTED
  UNDER_REVIEW
  APPROVED
  PROCESSING
  COMPLETED
  PARTIALLY_COMPLETED
  FAILED
  REJECTED
  CANCELLED
}

enum RefundTransactionStatus {
  CREATED
  PROCESSING
  SUCCEEDED
  FAILED
}

enum DisputeStatus {
  OPEN
  AWAITING_CUSTOMER
  AWAITING_VENDOR
  UNDER_REVIEW
  RESOLVED
  REJECTED
  CLOSED
}

enum DisputeType {
  ORDER
  PAYMENT
  SHIPPING
  RETURN
  REFUND
  PRODUCT
  OTHER
}

enum DisputeMessageAuthorType {
  CUSTOMER
  VENDOR
  STAFF
  SYSTEM
}

enum ReviewType {
  PRODUCT
  VENDOR
}

enum ReviewStatus {
  PENDING
  PUBLISHED
  REJECTED
  HIDDEN
}

enum NotificationStatus {
  PENDING
  QUEUED
  PROCESSING
  SENT
  PARTIALLY_FAILED
  FAILED
  CANCELLED
}

enum NotificationChannel {
  EMAIL
  SMS
  WHATSAPP
  PUSH
  IN_APP
}

enum NotificationDeliveryStatus {
  PENDING
  QUEUED
  SENDING
  DELIVERED
  FAILED
  SKIPPED
}

enum SupportCaseStatus {
  OPEN
  IN_PROGRESS
  WAITING_CUSTOMER
  WAITING_PROVIDER
  RESOLVED
  CLOSED
}

enum SupportPriority {
  LOW
  NORMAL
  HIGH
  URGENT
}

enum AuditActorType {
  USER
  SYSTEM
  PROVIDER
}

enum ReconciliationType {
  PAYMENT
  REFUND
  SETTLEMENT
}

enum ReconciliationRunStatus {
  PENDING
  RUNNING
  COMPLETED
  COMPLETED_WITH_MISMATCHES
  FAILED
}

enum ReconciliationItemStatus {
  MATCHED
  MISMATCHED
  MISSING_INTERNAL
  MISSING_PROVIDER
  RESOLVED
}

model User {
  id                          String                      @id @default(uuid()) @db.Uuid
  zitadelUserId               String                      @unique @db.VarChar(200)
  preferences                 Json?
  createdAt                   DateTime                    @default(now()) @db.Timestamptz(3)
  updatedAt                   DateTime                    @updatedAt @db.Timestamptz(3)
  archivedAt                  DateTime?                   @db.Timestamptz(3)
  addresses                   Address[]
  vendorApplications          Vendor[]                    @relation("VendorApplicant")
  vendorStatusActions         VendorStatusHistory[]       @relation("VendorStatusActor")
  vendorVerificationsReviewed VendorVerification[]        @relation("VendorVerificationReviewer")
  verificationHistoryActions  VendorVerificationHistory[] @relation("VendorVerificationActor")
  productsCreated             Product[]                   @relation("ProductCreator")
  productStatusActions        ProductStatusHistory[]      @relation("ProductStatusActor")
  mediaUploaded               MediaAsset[]                @relation("MediaUploader")
  inventoryReservations       InventoryReservation[]
  inventoryMovements          InventoryMovement[]         @relation("InventoryMovementActor")
  cart                        Cart?
  checkoutSessions            CheckoutSession[]
  orders                      MarketplaceOrder[]          @relation("CustomerOrders")
  orderStatusActions          OrderStatusHistory[]        @relation("OrderStatusActor")
  vendorOrderStatusActions    VendorOrderStatusHistory[]  @relation("VendorOrderStatusActor")
  payments                    Payment[]
  promotionRedemptions        PromotionRedemption[]
  refundsRequested            Refund[]                    @relation("RefundRequester")
  refundsApproved             Refund[]                    @relation("RefundApprover")
  returnRequests              ReturnRequest[]             @relation("ReturnRequester")
  returnsReviewed             ReturnRequest[]             @relation("ReturnReviewer")
  disputesOpened              Dispute[]                   @relation("DisputeOpener")
  disputesResolved            Dispute[]                   @relation("DisputeResolver")
  disputeMessages             DisputeMessage[]            @relation("DisputeMessageAuthor")
  reviews                     Review[]                    @relation("ReviewCustomer")
  reviewsModerated            Review[]                    @relation("ReviewModerator")
  notifications               Notification[]
  supportCases                SupportCase[]
  auditLogs                   AuditLog[]                  @relation("AuditActor")
  idempotencyKeys             IdempotencyKey[]
  fulfillmentsHandled         Fulfillment[]               @relation("FulfillmentHandler")
  ledgerEntriesCreated        VendorLedgerEntry[]         @relation("LedgerEntryCreator")
  reconciliationItemsResolved ReconciliationItem[]        @relation("ReconciliationResolver")

  @@index([archivedAt])
}

model Address {
  id          String      @id @default(uuid()) @db.Uuid
  userId      String      @db.Uuid
  type        AddressType @default(HOME)
  label       String?     @db.VarChar(80)
  fullName    String      @db.VarChar(200)
  phone       String      @db.VarChar(32)
  line1       String      @db.VarChar(255)
  line2       String?     @db.VarChar(255)
  city        String      @db.VarChar(120)
  state       String      @db.VarChar(120)
  postalCode  String      @db.VarChar(24)
  countryCode String      @default("IN") @db.Char(2)
  isDefault   Boolean     @default(false)
  createdAt   DateTime    @default(now()) @db.Timestamptz(3)
  updatedAt   DateTime    @updatedAt @db.Timestamptz(3)
  user        User        @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@index([userId, isDefault])
}

model Vendor {
  id                     String                    @id @default(uuid()) @db.Uuid
  slug                   String                    @unique @db.VarChar(120)
  displayName            String                    @db.VarChar(180)
  legalName              String?                   @db.VarChar(220)
  description            String?                   @db.Text
  contactEmail           String                    @db.VarChar(320)
  contactPhone           String?                   @db.VarChar(32)
  status                 VendorStatus              @default(REGISTERED)
  zitadelOrganizationId  String?                   @unique @db.VarChar(200)
  iamProvisioningStatus  IamProvisioningStatus     @default(NOT_PROVISIONED)
  taxIdentifier          String?                   @unique @db.VarChar(64)
  payoutProvider         String?                   @db.VarChar(80)
  payoutAccountReference String?                   @db.VarChar(255)
  settings               Json?
  appliedById            String                    @db.Uuid
  approvedAt             DateTime?                 @db.Timestamptz(3)
  suspendedAt            DateTime?                 @db.Timestamptz(3)
  createdAt              DateTime                  @default(now()) @db.Timestamptz(3)
  updatedAt              DateTime                  @updatedAt @db.Timestamptz(3)
  appliedBy              User                      @relation("VendorApplicant", fields: [appliedById], references: [id], onDelete: Restrict)
  verifications          VendorVerification[]
  statusHistory          VendorStatusHistory[]
  products               Product[]
  promotions             Promotion[]
  vendorOrders           VendorOrder[]
  orderItems             OrderItem[]
  commissionRules        CommissionRule[]
  commissionSnapshots    OrderCommissionSnapshot[]
  ledgerEntries          VendorLedgerEntry[]
  settlements            Settlement[]
  reviews                Review[]
  disputes               Dispute[]

  @@index([status, createdAt])
  @@index([appliedById])
}

model IamProvisioningOperation {
  id                  String                         @id @default(uuid()) @db.Uuid
  idempotencyKey      String                         @unique @db.VarChar(200)
  operationType       IamProvisioningOperationType
  aggregateType       String                         @db.VarChar(80)
  aggregateId         String                         @db.VarChar(200)
  targetZitadelUserId String?                        @db.VarChar(200)
  status              IamProvisioningOperationStatus @default(PENDING)
  providerResourceId  String?                        @db.VarChar(200)
  attempts            Int                            @default(0)
  lastErrorCode       String?                        @db.VarChar(120)
  lastErrorMessage    String?                        @db.VarChar(500)
  nextAttemptAt       DateTime?                      @db.Timestamptz(3)
  completedAt         DateTime?                      @db.Timestamptz(3)
  createdAt           DateTime                       @default(now()) @db.Timestamptz(3)
  updatedAt           DateTime                       @updatedAt @db.Timestamptz(3)

  @@index([status, nextAttemptAt, createdAt])
  @@index([aggregateType, aggregateId, createdAt])
  @@index([aggregateId, targetZitadelUserId, operationType, status])
}

model VendorVerification {
  id                String                      @id @default(uuid()) @db.Uuid
  vendorId          String                      @db.Uuid
  status            VendorVerificationStatus    @default(DRAFT)
  provider          String?                     @db.VarChar(80)
  providerReference String?                     @db.VarChar(255)
  submittedAt       DateTime?                   @db.Timestamptz(3)
  reviewedAt        DateTime?                   @db.Timestamptz(3)
  reviewedById      String?                     @db.Uuid
  reviewNotes       String?                     @db.Text
  rejectionReason   String?                     @db.Text
  metadata          Json?
  createdAt         DateTime                    @default(now()) @db.Timestamptz(3)
  updatedAt         DateTime                    @updatedAt @db.Timestamptz(3)
  vendor            Vendor                      @relation(fields: [vendorId], references: [id], onDelete: Cascade)
  reviewedBy        User?                       @relation("VendorVerificationReviewer", fields: [reviewedById], references: [id], onDelete: SetNull)
  documents         VendorDocumentReference[]
  history           VendorVerificationHistory[]

  @@unique([provider, providerReference])
  @@index([vendorId, status, createdAt])
  @@index([reviewedById])
}

model VendorDocumentReference {
  id               String             @id @default(uuid()) @db.Uuid
  verificationId   String             @db.Uuid
  type             VendorDocumentType
  provider         String             @db.VarChar(80)
  storageReference String             @db.VarChar(500)
  fileName         String?            @db.VarChar(255)
  mimeType         String?            @db.VarChar(120)
  checksum         String?            @db.VarChar(128)
  metadata         Json?
  expiresAt        DateTime?          @db.Timestamptz(3)
  createdAt        DateTime           @default(now()) @db.Timestamptz(3)
  verification     VendorVerification @relation(fields: [verificationId], references: [id], onDelete: Cascade)

  @@unique([provider, storageReference])
  @@index([verificationId, type])
}

model VendorStatusHistory {
  id         String        @id @default(uuid()) @db.Uuid
  vendorId   String        @db.Uuid
  fromStatus VendorStatus?
  toStatus   VendorStatus
  actorId    String?       @db.Uuid
  reason     String?       @db.Text
  metadata   Json?
  createdAt  DateTime      @default(now()) @db.Timestamptz(3)
  vendor     Vendor        @relation(fields: [vendorId], references: [id], onDelete: Cascade)
  actor      User?         @relation("VendorStatusActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([vendorId, createdAt])
  @@index([actorId])
}

model VendorVerificationHistory {
  id             String                    @id @default(uuid()) @db.Uuid
  verificationId String                    @db.Uuid
  fromStatus     VendorVerificationStatus?
  toStatus       VendorVerificationStatus
  actorId        String?                   @db.Uuid
  reason         String?                   @db.Text
  createdAt      DateTime                  @default(now()) @db.Timestamptz(3)
  verification   VendorVerification        @relation(fields: [verificationId], references: [id], onDelete: Cascade)
  actor          User?                     @relation("VendorVerificationActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([verificationId, createdAt])
  @@index([actorId])
}

model Category {
  id              String              @id @default(uuid()) @db.Uuid
  parentId        String?             @db.Uuid
  name            String              @db.VarChar(160)
  slug            String              @unique @db.VarChar(180)
  description     String?             @db.Text
  status          CategoryStatus      @default(ACTIVE)
  sortOrder       Int                 @default(0)
  metadata        Json?
  createdAt       DateTime            @default(now()) @db.Timestamptz(3)
  updatedAt       DateTime            @updatedAt @db.Timestamptz(3)
  parent          Category?           @relation("CategoryTree", fields: [parentId], references: [id], onDelete: SetNull)
  children        Category[]          @relation("CategoryTree")
  attributes      CategoryAttribute[]
  products        Product[]
  commissionRules CommissionRule[]

  @@index([parentId, status, sortOrder])
}

model Attribute {
  id            String                         @id @default(uuid()) @db.Uuid
  code          String                         @unique @db.VarChar(100)
  name          String                         @db.VarChar(160)
  type          AttributeType
  isVariant     Boolean                        @default(false)
  isFilterable  Boolean                        @default(false)
  createdAt     DateTime                       @default(now()) @db.Timestamptz(3)
  updatedAt     DateTime                       @updatedAt @db.Timestamptz(3)
  options       AttributeOption[]
  categories    CategoryAttribute[]
  productValues ProductAttributeValue[]
  variantValues ProductVariantAttributeValue[]
}

model AttributeOption {
  id            String                         @id @default(uuid()) @db.Uuid
  attributeId   String                         @db.Uuid
  value         String                         @db.VarChar(160)
  label         String                         @db.VarChar(160)
  sortOrder     Int                            @default(0)
  metadata      Json?
  attribute     Attribute                      @relation(fields: [attributeId], references: [id], onDelete: Cascade)
  productValues ProductAttributeValue[]
  variantValues ProductVariantAttributeValue[]

  @@unique([attributeId, value])
  @@index([attributeId, sortOrder])
}

model CategoryAttribute {
  categoryId   String    @db.Uuid
  attributeId  String    @db.Uuid
  isRequired   Boolean   @default(false)
  isFilterable Boolean   @default(false)
  sortOrder    Int       @default(0)
  category     Category  @relation(fields: [categoryId], references: [id], onDelete: Cascade)
  attribute    Attribute @relation(fields: [attributeId], references: [id], onDelete: Cascade)

  @@id([categoryId, attributeId])
  @@index([attributeId])
}

model Product {
  id               String                  @id @default(uuid()) @db.Uuid
  vendorId         String                  @db.Uuid
  categoryId       String                  @db.Uuid
  name             String                  @db.VarChar(240)
  slug             String                  @db.VarChar(260)
  description      String                  @db.Text
  shortDescription String?                 @db.VarChar(500)
  status           ProductStatus           @default(DRAFT)
  currency         String                  @default("INR") @db.Char(3)
  metadata         Json?
  createdById      String                  @db.Uuid
  submittedAt      DateTime?               @db.Timestamptz(3)
  approvedAt       DateTime?               @db.Timestamptz(3)
  publishedAt      DateTime?               @db.Timestamptz(3)
  createdAt        DateTime                @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime                @updatedAt @db.Timestamptz(3)
  vendor           Vendor                  @relation(fields: [vendorId], references: [id], onDelete: Restrict)
  category         Category                @relation(fields: [categoryId], references: [id], onDelete: Restrict)
  createdBy        User                    @relation("ProductCreator", fields: [createdById], references: [id], onDelete: Restrict)
  variants         ProductVariant[]
  attributeValues  ProductAttributeValue[]
  media            ProductMedia[]
  statusHistory    ProductStatusHistory[]
  orderItems       OrderItem[]
  reviews          Review[]

  @@unique([vendorId, slug])
  @@index([status, publishedAt])
  @@index([categoryId, status, publishedAt])
  @@index([vendorId, status, updatedAt])
}

model ProductVariant {
  id                  String                         @id @default(uuid()) @db.Uuid
  productId           String                         @db.Uuid
  sku                 String                         @unique @db.VarChar(120)
  name                String?                        @db.VarChar(200)
  status              ProductVariantStatus           @default(ACTIVE)
  priceMinor          BigInt
  compareAtPriceMinor BigInt?
  currency            String                         @default("INR") @db.Char(3)
  weightGrams         Int?
  metadata            Json?
  createdAt           DateTime                       @default(now()) @db.Timestamptz(3)
  updatedAt           DateTime                       @updatedAt @db.Timestamptz(3)
  product             Product                        @relation(fields: [productId], references: [id], onDelete: Cascade)
  attributeValues     ProductVariantAttributeValue[]
  media               ProductMedia[]
  inventory           Inventory?
  cartItems           CartItem[]
  orderItems          OrderItem[]

  @@index([productId, status])
  @@index([status, priceMinor])
}

model ProductAttributeValue {
  id           String           @id @default(uuid()) @db.Uuid
  productId    String           @db.Uuid
  attributeId  String           @db.Uuid
  optionId     String?          @db.Uuid
  valueText    String?          @db.Text
  valueNumber  Decimal?         @db.Decimal(20, 6)
  valueBoolean Boolean?
  product      Product          @relation(fields: [productId], references: [id], onDelete: Cascade)
  attribute    Attribute        @relation(fields: [attributeId], references: [id], onDelete: Restrict)
  option       AttributeOption? @relation(fields: [optionId], references: [id], onDelete: Restrict)

  @@unique([productId, attributeId])
  @@index([attributeId, optionId])
}

model ProductVariantAttributeValue {
  id          String           @id @default(uuid()) @db.Uuid
  variantId   String           @db.Uuid
  attributeId String           @db.Uuid
  optionId    String?          @db.Uuid
  valueText   String?          @db.Text
  variant     ProductVariant   @relation(fields: [variantId], references: [id], onDelete: Cascade)
  attribute   Attribute        @relation(fields: [attributeId], references: [id], onDelete: Restrict)
  option      AttributeOption? @relation(fields: [optionId], references: [id], onDelete: Restrict)

  @@unique([variantId, attributeId])
  @@index([attributeId, optionId])
}

model MediaAsset {
  id                String         @id @default(uuid()) @db.Uuid
  provider          String         @db.VarChar(80)
  providerReference String         @db.VarChar(500)
  url               String         @db.Text
  mimeType          String         @db.VarChar(120)
  sizeBytes         BigInt?
  checksum          String?        @db.VarChar(128)
  width             Int?
  height            Int?
  metadata          Json?
  uploadedById      String?        @db.Uuid
  createdAt         DateTime       @default(now()) @db.Timestamptz(3)
  uploadedBy        User?          @relation("MediaUploader", fields: [uploadedById], references: [id], onDelete: SetNull)
  productLinks      ProductMedia[]

  @@unique([provider, providerReference])
  @@index([uploadedById, createdAt])
}

model ProductMedia {
  id           String          @id @default(uuid()) @db.Uuid
  productId    String          @db.Uuid
  variantId    String?         @db.Uuid
  mediaAssetId String          @db.Uuid
  altText      String?         @db.VarChar(300)
  sortOrder    Int             @default(0)
  isPrimary    Boolean         @default(false)
  createdAt    DateTime        @default(now()) @db.Timestamptz(3)
  product      Product         @relation(fields: [productId], references: [id], onDelete: Cascade)
  variant      ProductVariant? @relation(fields: [variantId], references: [id], onDelete: Cascade)
  mediaAsset   MediaAsset      @relation(fields: [mediaAssetId], references: [id], onDelete: Restrict)

  @@unique([productId, mediaAssetId])
  @@index([productId, sortOrder])
  @@index([variantId])
}

model ProductStatusHistory {
  id         String         @id @default(uuid()) @db.Uuid
  productId  String         @db.Uuid
  fromStatus ProductStatus?
  toStatus   ProductStatus
  actorId    String?        @db.Uuid
  reason     String?        @db.Text
  metadata   Json?
  createdAt  DateTime       @default(now()) @db.Timestamptz(3)
  product    Product        @relation(fields: [productId], references: [id], onDelete: Cascade)
  actor      User?          @relation("ProductStatusActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([productId, createdAt])
  @@index([actorId])
}

model Inventory {
  id                String                 @id @default(uuid()) @db.Uuid
  productVariantId  String                 @unique @db.Uuid
  availableQuantity Int                    @default(0)
  reservedQuantity  Int                    @default(0)
  committedQuantity Int                    @default(0)
  reorderThreshold  Int                    @default(0)
  version           Int                    @default(0)
  createdAt         DateTime               @default(now()) @db.Timestamptz(3)
  updatedAt         DateTime               @updatedAt @db.Timestamptz(3)
  productVariant    ProductVariant         @relation(fields: [productVariantId], references: [id], onDelete: Restrict)
  reservations      InventoryReservation[]
  movements         InventoryMovement[]

  @@index([availableQuantity])
}

model InventoryReservation {
  id                 String                     @id @default(uuid()) @db.Uuid
  inventoryId        String                     @db.Uuid
  userId             String                     @db.Uuid
  checkoutSessionId  String?                    @db.Uuid
  marketplaceOrderId String?                    @db.Uuid
  quantity           Int
  status             InventoryReservationStatus @default(HELD)
  expiresAt          DateTime                   @db.Timestamptz(3)
  committedAt        DateTime?                  @db.Timestamptz(3)
  releasedAt         DateTime?                  @db.Timestamptz(3)
  createdAt          DateTime                   @default(now()) @db.Timestamptz(3)
  updatedAt          DateTime                   @updatedAt @db.Timestamptz(3)
  inventory          Inventory                  @relation(fields: [inventoryId], references: [id], onDelete: Restrict)
  user               User                       @relation(fields: [userId], references: [id], onDelete: Restrict)
  checkoutSession    CheckoutSession?           @relation(fields: [checkoutSessionId], references: [id], onDelete: SetNull)
  marketplaceOrder   MarketplaceOrder?          @relation(fields: [marketplaceOrderId], references: [id], onDelete: SetNull)
  movements          InventoryMovement[]

  @@index([inventoryId, status, expiresAt])
  @@index([checkoutSessionId])
  @@index([marketplaceOrderId])
  @@index([userId, status])
}

model InventoryMovement {
  id                 String                @id @default(uuid()) @db.Uuid
  inventoryId        String                @db.Uuid
  reservationId      String?               @db.Uuid
  marketplaceOrderId String?               @db.Uuid
  type               InventoryMovementType
  quantityDelta      Int
  availableDelta     Int                   @default(0)
  reservedDelta      Int                   @default(0)
  committedDelta     Int                   @default(0)
  referenceType      String?               @db.VarChar(100)
  referenceId        String?               @db.VarChar(120)
  reason             String?               @db.Text
  actorId            String?               @db.Uuid
  createdAt          DateTime              @default(now()) @db.Timestamptz(3)
  inventory          Inventory             @relation(fields: [inventoryId], references: [id], onDelete: Restrict)
  reservation        InventoryReservation? @relation(fields: [reservationId], references: [id], onDelete: SetNull)
  marketplaceOrder   MarketplaceOrder?     @relation(fields: [marketplaceOrderId], references: [id], onDelete: SetNull)
  actor              User?                 @relation("InventoryMovementActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([inventoryId, createdAt])
  @@index([reservationId])
  @@index([marketplaceOrderId])
  @@index([referenceType, referenceId])
}

model Cart {
  id               String            @id @default(uuid()) @db.Uuid
  userId           String            @unique @db.Uuid
  status           CartStatus        @default(ACTIVE)
  currency         String            @default("INR") @db.Char(3)
  createdAt        DateTime          @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime          @updatedAt @db.Timestamptz(3)
  user             User              @relation(fields: [userId], references: [id], onDelete: Cascade)
  items            CartItem[]
  checkoutSessions CheckoutSession[]

  @@index([status, updatedAt])
}

model CartItem {
  id               String         @id @default(uuid()) @db.Uuid
  cartId           String         @db.Uuid
  productVariantId String         @db.Uuid
  quantity         Int
  createdAt        DateTime       @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime       @updatedAt @db.Timestamptz(3)
  cart             Cart           @relation(fields: [cartId], references: [id], onDelete: Cascade)
  productVariant   ProductVariant @relation(fields: [productVariantId], references: [id], onDelete: Restrict)

  @@unique([cartId, productVariantId])
  @@index([productVariantId])
}

model Promotion {
  id                   String                @id @default(uuid()) @db.Uuid
  vendorId             String?               @db.Uuid
  name                 String                @db.VarChar(200)
  description          String?               @db.Text
  type                 PromotionType
  funding              PromotionFunding      @default(MARKETPLACE)
  percentageBps        Int?
  amountMinor          BigInt?
  currency             String                @default("INR") @db.Char(3)
  minimumSpendMinor    BigInt                @default(0)
  maximumDiscountMinor BigInt?
  status               PromotionStatus       @default(DRAFT)
  startsAt             DateTime              @db.Timestamptz(3)
  endsAt               DateTime?             @db.Timestamptz(3)
  totalUsageLimit      Int?
  perUserUsageLimit    Int?                  @default(1)
  rules                Json?
  createdAt            DateTime              @default(now()) @db.Timestamptz(3)
  updatedAt            DateTime              @updatedAt @db.Timestamptz(3)
  vendor               Vendor?               @relation(fields: [vendorId], references: [id], onDelete: Cascade)
  coupons              Coupon[]
  redemptions          PromotionRedemption[]

  @@index([status, startsAt, endsAt])
  @@index([vendorId, status])
}

model Coupon {
  id                String                @id @default(uuid()) @db.Uuid
  promotionId       String                @db.Uuid
  code              String                @unique @db.VarChar(64)
  usageLimit        Int?
  perUserUsageLimit Int?                  @default(1)
  startsAt          DateTime?             @db.Timestamptz(3)
  endsAt            DateTime?             @db.Timestamptz(3)
  isActive          Boolean               @default(true)
  createdAt         DateTime              @default(now()) @db.Timestamptz(3)
  updatedAt         DateTime              @updatedAt @db.Timestamptz(3)
  promotion         Promotion             @relation(fields: [promotionId], references: [id], onDelete: Cascade)
  redemptions       PromotionRedemption[]

  @@index([promotionId, isActive])
}

model PromotionRedemption {
  id                 String           @id @default(uuid()) @db.Uuid
  promotionId        String           @db.Uuid
  couponId           String?          @db.Uuid
  userId             String           @db.Uuid
  marketplaceOrderId String           @db.Uuid
  discountMinor      BigInt
  currency           String           @default("INR") @db.Char(3)
  createdAt          DateTime         @default(now()) @db.Timestamptz(3)
  promotion          Promotion        @relation(fields: [promotionId], references: [id], onDelete: Restrict)
  coupon             Coupon?          @relation(fields: [couponId], references: [id], onDelete: Restrict)
  user               User             @relation(fields: [userId], references: [id], onDelete: Restrict)
  marketplaceOrder   MarketplaceOrder @relation(fields: [marketplaceOrderId], references: [id], onDelete: Restrict)

  @@unique([promotionId, marketplaceOrderId])
  @@index([userId, promotionId, createdAt])
  @@index([couponId])
}

model CheckoutSession {
  id               String                 @id @default(uuid()) @db.Uuid
  userId           String                 @db.Uuid
  cartId           String                 @db.Uuid
  status           CheckoutStatus         @default(CREATED)
  idempotencyKey   String                 @unique @db.VarChar(160)
  currency         String                 @default("INR") @db.Char(3)
  subtotalMinor    BigInt
  discountMinor    BigInt                 @default(0)
  taxMinor         BigInt                 @default(0)
  shippingMinor    BigInt                 @default(0)
  totalMinor       BigInt
  shippingAddress  Json
  billingAddress   Json?
  pricingSnapshot  Json
  expiresAt        DateTime               @db.Timestamptz(3)
  completedAt      DateTime?              @db.Timestamptz(3)
  createdAt        DateTime               @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime               @updatedAt @db.Timestamptz(3)
  user             User                   @relation(fields: [userId], references: [id], onDelete: Restrict)
  cart             Cart                   @relation(fields: [cartId], references: [id], onDelete: Restrict)
  reservations     InventoryReservation[]
  payments         Payment[]
  marketplaceOrder MarketplaceOrder?

  @@index([userId, status, createdAt])
  @@index([status, expiresAt])
}

model MarketplaceOrder {
  id                    String                 @id @default(uuid()) @db.Uuid
  orderNumber           String                 @unique @db.VarChar(64)
  customerId            String                 @db.Uuid
  checkoutSessionId     String?                @unique @db.Uuid
  status                MarketplaceOrderStatus @default(CREATED)
  currency              String                 @default("INR") @db.Char(3)
  subtotalMinor         BigInt
  discountMinor         BigInt                 @default(0)
  taxMinor              BigInt                 @default(0)
  shippingMinor         BigInt                 @default(0)
  totalMinor            BigInt
  refundedMinor         BigInt                 @default(0)
  shippingAddress       Json
  billingAddress        Json?
  placedAt              DateTime               @default(now()) @db.Timestamptz(3)
  confirmedAt           DateTime?              @db.Timestamptz(3)
  completedAt           DateTime?              @db.Timestamptz(3)
  cancelledAt           DateTime?              @db.Timestamptz(3)
  cancellationReason    String?                @db.Text
  createdAt             DateTime               @default(now()) @db.Timestamptz(3)
  updatedAt             DateTime               @updatedAt @db.Timestamptz(3)
  customer              User                   @relation("CustomerOrders", fields: [customerId], references: [id], onDelete: Restrict)
  checkoutSession       CheckoutSession?       @relation(fields: [checkoutSessionId], references: [id], onDelete: SetNull)
  vendorOrders          VendorOrder[]
  items                 OrderItem[]
  statusHistory         OrderStatusHistory[]
  inventoryReservations InventoryReservation[]
  inventoryMovements    InventoryMovement[]
  payments              Payment[]
  promotionRedemptions  PromotionRedemption[]
  refunds               Refund[]
  returnRequests        ReturnRequest[]
  disputes              Dispute[]
  supportCases          SupportCase[]

  @@index([customerId, createdAt])
  @@index([status, createdAt])
}

model VendorOrder {
  id                  String                     @id @default(uuid()) @db.Uuid
  marketplaceOrderId  String                     @db.Uuid
  vendorId            String                     @db.Uuid
  orderNumber         String                     @unique @db.VarChar(72)
  status              VendorOrderStatus          @default(PENDING)
  currency            String                     @default("INR") @db.Char(3)
  subtotalMinor       BigInt
  discountMinor       BigInt                     @default(0)
  taxMinor            BigInt                     @default(0)
  shippingMinor       BigInt                     @default(0)
  totalMinor          BigInt
  commissionMinor     BigInt                     @default(0)
  vendorEarningMinor  BigInt                     @default(0)
  acceptedAt          DateTime?                  @db.Timestamptz(3)
  readyToShipAt       DateTime?                  @db.Timestamptz(3)
  shippedAt           DateTime?                  @db.Timestamptz(3)
  deliveredAt         DateTime?                  @db.Timestamptz(3)
  cancelledAt         DateTime?                  @db.Timestamptz(3)
  createdAt           DateTime                   @default(now()) @db.Timestamptz(3)
  updatedAt           DateTime                   @updatedAt @db.Timestamptz(3)
  marketplaceOrder    MarketplaceOrder           @relation(fields: [marketplaceOrderId], references: [id], onDelete: Restrict)
  vendor              Vendor                     @relation(fields: [vendorId], references: [id], onDelete: Restrict)
  items               OrderItem[]
  statusHistory       VendorOrderStatusHistory[]
  commissionSnapshots OrderCommissionSnapshot[]
  ledgerEntries       VendorLedgerEntry[]
  fulfillment         Fulfillment?
  shipments           Shipment[]
  disputes            Dispute[]

  @@unique([marketplaceOrderId, vendorId])
  @@index([vendorId, status, createdAt])
  @@index([marketplaceOrderId])
}

model OrderItem {
  id                   String                   @id @default(uuid()) @db.Uuid
  marketplaceOrderId   String                   @db.Uuid
  vendorOrderId        String                   @db.Uuid
  vendorId             String                   @db.Uuid
  productId            String?                  @db.Uuid
  productVariantId     String?                  @db.Uuid
  productName          String                   @db.VarChar(240)
  sku                  String                   @db.VarChar(120)
  vendorName           String                   @db.VarChar(180)
  quantity             Int
  refundedQuantity     Int                      @default(0)
  unitPriceMinor       BigInt
  subtotalMinor        BigInt
  discountMinor        BigInt                   @default(0)
  taxMinor             BigInt                   @default(0)
  totalMinor           BigInt
  commissionBasisMinor BigInt
  currency             String                   @default("INR") @db.Char(3)
  productSnapshot      Json
  createdAt            DateTime                 @default(now()) @db.Timestamptz(3)
  marketplaceOrder     MarketplaceOrder         @relation(fields: [marketplaceOrderId], references: [id], onDelete: Restrict)
  vendorOrder          VendorOrder              @relation(fields: [vendorOrderId], references: [id], onDelete: Restrict)
  vendor               Vendor                   @relation(fields: [vendorId], references: [id], onDelete: Restrict)
  product              Product?                 @relation(fields: [productId], references: [id], onDelete: SetNull)
  productVariant       ProductVariant?          @relation(fields: [productVariantId], references: [id], onDelete: SetNull)
  commissionSnapshot   OrderCommissionSnapshot?
  ledgerEntries        VendorLedgerEntry[]
  returnItems          ReturnItem[]
  reviews              Review[]

  @@index([marketplaceOrderId])
  @@index([vendorOrderId])
  @@index([vendorId])
  @@index([productId])
  @@index([productVariantId])
}

model OrderStatusHistory {
  id                 String                  @id @default(uuid()) @db.Uuid
  marketplaceOrderId String                  @db.Uuid
  fromStatus         MarketplaceOrderStatus?
  toStatus           MarketplaceOrderStatus
  actorId            String?                 @db.Uuid
  reason             String?                 @db.Text
  metadata           Json?
  createdAt          DateTime                @default(now()) @db.Timestamptz(3)
  marketplaceOrder   MarketplaceOrder        @relation(fields: [marketplaceOrderId], references: [id], onDelete: Cascade)
  actor              User?                   @relation("OrderStatusActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([marketplaceOrderId, createdAt])
  @@index([actorId])
}

model VendorOrderStatusHistory {
  id            String             @id @default(uuid()) @db.Uuid
  vendorOrderId String             @db.Uuid
  fromStatus    VendorOrderStatus?
  toStatus      VendorOrderStatus
  actorId       String?            @db.Uuid
  reason        String?            @db.Text
  metadata      Json?
  createdAt     DateTime           @default(now()) @db.Timestamptz(3)
  vendorOrder   VendorOrder        @relation(fields: [vendorOrderId], references: [id], onDelete: Cascade)
  actor         User?              @relation("VendorOrderStatusActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([vendorOrderId, createdAt])
  @@index([actorId])
}

model Payment {
  id                       String               @id @default(uuid()) @db.Uuid
  checkoutSessionId        String?              @db.Uuid
  marketplaceOrderId       String?              @db.Uuid
  customerId               String               @db.Uuid
  provider                 String               @db.VarChar(80)
  providerPaymentReference String?              @db.VarChar(255)
  status                   PaymentStatus        @default(CREATED)
  amountMinor              BigInt
  refundedMinor            BigInt               @default(0)
  currency                 String               @default("INR") @db.Char(3)
  idempotencyKey           String               @unique @db.VarChar(160)
  metadata                 Json?
  authorizedAt             DateTime?            @db.Timestamptz(3)
  capturedAt               DateTime?            @db.Timestamptz(3)
  failedAt                 DateTime?            @db.Timestamptz(3)
  createdAt                DateTime             @default(now()) @db.Timestamptz(3)
  updatedAt                DateTime             @updatedAt @db.Timestamptz(3)
  checkoutSession          CheckoutSession?     @relation(fields: [checkoutSessionId], references: [id], onDelete: SetNull)
  marketplaceOrder         MarketplaceOrder?    @relation(fields: [marketplaceOrderId], references: [id], onDelete: SetNull)
  customer                 User                 @relation(fields: [customerId], references: [id], onDelete: Restrict)
  attempts                 PaymentAttempt[]
  refunds                  Refund[]
  reconciliationItems      ReconciliationItem[]
  supportCases             SupportCase[]

  @@unique([provider, providerPaymentReference])
  @@index([customerId, createdAt])
  @@index([marketplaceOrderId])
  @@index([checkoutSessionId])
  @@index([status, createdAt])
}

model PaymentAttempt {
  id                       String               @id @default(uuid()) @db.Uuid
  paymentId                String               @db.Uuid
  attemptNumber            Int
  providerAttemptReference String?              @db.VarChar(255)
  status                   PaymentAttemptStatus @default(CREATED)
  amountMinor              BigInt
  currency                 String               @default("INR") @db.Char(3)
  errorCode                String?              @db.VarChar(100)
  errorMessage             String?              @db.Text
  providerResponse         Json?
  completedAt              DateTime?            @db.Timestamptz(3)
  createdAt                DateTime             @default(now()) @db.Timestamptz(3)
  updatedAt                DateTime             @updatedAt @db.Timestamptz(3)
  payment                  Payment              @relation(fields: [paymentId], references: [id], onDelete: Cascade)

  @@unique([paymentId, attemptNumber])
  @@index([providerAttemptReference])
  @@index([status, createdAt])
}

model WebhookEvent {
  id              String                  @id @default(uuid()) @db.Uuid
  provider        String                  @db.VarChar(80)
  providerEventId String                  @db.VarChar(255)
  eventType       String                  @db.VarChar(160)
  signatureValid  Boolean
  status          WebhookProcessingStatus @default(RECEIVED)
  payload         Json
  headers         Json?
  attempts        Int                     @default(0)
  processedAt     DateTime?               @db.Timestamptz(3)
  lastError       String?                 @db.Text
  createdAt       DateTime                @default(now()) @db.Timestamptz(3)
  updatedAt       DateTime                @updatedAt @db.Timestamptz(3)

  @@unique([provider, providerEventId])
  @@index([status, createdAt])
  @@index([provider, eventType, createdAt])
}

model IdempotencyKey {
  id             String            @id @default(uuid()) @db.Uuid
  scope          String            @db.VarChar(120)
  key            String            @db.VarChar(160)
  userId         String?           @db.Uuid
  requestHash    String            @db.VarChar(128)
  status         IdempotencyStatus @default(PROCESSING)
  responseStatus Int?
  responseBody   Json?
  resourceType   String?           @db.VarChar(100)
  resourceId     String?           @db.VarChar(120)
  lockedAt       DateTime          @default(now()) @db.Timestamptz(3)
  expiresAt      DateTime          @db.Timestamptz(3)
  createdAt      DateTime          @default(now()) @db.Timestamptz(3)
  updatedAt      DateTime          @updatedAt @db.Timestamptz(3)
  user           User?             @relation(fields: [userId], references: [id], onDelete: SetNull)

  @@unique([scope, key])
  @@index([userId, createdAt])
  @@index([status, expiresAt])
}

model CommissionRule {
  id            String                    @id @default(uuid()) @db.Uuid
  name          String                    @db.VarChar(180)
  scope         CommissionRuleScope
  vendorId      String?                   @db.Uuid
  categoryId    String?                   @db.Uuid
  rateBps       Int
  flatFeeMinor  BigInt                    @default(0)
  currency      String                    @default("INR") @db.Char(3)
  priority      Int                       @default(0)
  isActive      Boolean                   @default(true)
  effectiveFrom DateTime                  @default(now()) @db.Timestamptz(3)
  effectiveTo   DateTime?                 @db.Timestamptz(3)
  createdAt     DateTime                  @default(now()) @db.Timestamptz(3)
  updatedAt     DateTime                  @updatedAt @db.Timestamptz(3)
  vendor        Vendor?                   @relation(fields: [vendorId], references: [id], onDelete: Cascade)
  category      Category?                 @relation(fields: [categoryId], references: [id], onDelete: Cascade)
  snapshots     OrderCommissionSnapshot[]

  @@index([scope, isActive, priority])
  @@index([vendorId, isActive, effectiveFrom])
  @@index([categoryId, isActive, effectiveFrom])
}

model OrderCommissionSnapshot {
  id                    String          @id @default(uuid()) @db.Uuid
  orderItemId           String          @unique @db.Uuid
  vendorOrderId         String          @db.Uuid
  vendorId              String          @db.Uuid
  commissionRuleId      String?         @db.Uuid
  basisAmountMinor      BigInt
  rateBps               Int
  flatFeeMinor          BigInt          @default(0)
  commissionAmountMinor BigInt
  currency              String          @default("INR") @db.Char(3)
  createdAt             DateTime        @default(now()) @db.Timestamptz(3)
  orderItem             OrderItem       @relation(fields: [orderItemId], references: [id], onDelete: Restrict)
  vendorOrder           VendorOrder     @relation(fields: [vendorOrderId], references: [id], onDelete: Restrict)
  vendor                Vendor          @relation(fields: [vendorId], references: [id], onDelete: Restrict)
  commissionRule        CommissionRule? @relation(fields: [commissionRuleId], references: [id], onDelete: SetNull)

  @@index([vendorOrderId])
  @@index([vendorId, createdAt])
  @@index([commissionRuleId])
}

model VendorLedgerEntry {
  id             String                @id @default(uuid()) @db.Uuid
  vendorId       String                @db.Uuid
  vendorOrderId  String?               @db.Uuid
  orderItemId    String?               @db.Uuid
  refundId       String?               @db.Uuid
  type           VendorLedgerEntryType
  direction      LedgerDirection
  amountMinor    BigInt
  currency       String                @default("INR") @db.Char(3)
  description    String                @db.VarChar(500)
  idempotencyKey String                @unique @db.VarChar(180)
  availableAt    DateTime?             @db.Timestamptz(3)
  createdById    String?               @db.Uuid
  metadata       Json?
  createdAt      DateTime              @default(now()) @db.Timestamptz(3)
  vendor         Vendor                @relation(fields: [vendorId], references: [id], onDelete: Restrict)
  vendorOrder    VendorOrder?          @relation(fields: [vendorOrderId], references: [id], onDelete: SetNull)
  orderItem      OrderItem?            @relation(fields: [orderItemId], references: [id], onDelete: SetNull)
  refund         Refund?               @relation(fields: [refundId], references: [id], onDelete: SetNull)
  createdBy      User?                 @relation("LedgerEntryCreator", fields: [createdById], references: [id], onDelete: SetNull)
  settlementItem SettlementItem?

  @@index([vendorId, currency, createdAt])
  @@index([vendorId, availableAt])
  @@index([vendorOrderId])
  @@index([refundId])
}

model Settlement {
  id                  String               @id @default(uuid()) @db.Uuid
  settlementNumber    String               @unique @db.VarChar(72)
  vendorId            String               @db.Uuid
  status              SettlementStatus     @default(PENDING)
  currency            String               @default("INR") @db.Char(3)
  grossAmountMinor    BigInt
  deductionsMinor     BigInt               @default(0)
  netAmountMinor      BigInt
  provider            String?              @db.VarChar(80)
  providerReference   String?              @db.VarChar(255)
  idempotencyKey      String               @unique @db.VarChar(180)
  eligibleAt          DateTime?            @db.Timestamptz(3)
  processingAt        DateTime?            @db.Timestamptz(3)
  settledAt           DateTime?            @db.Timestamptz(3)
  failedAt            DateTime?            @db.Timestamptz(3)
  failureReason       String?              @db.Text
  metadata            Json?
  createdAt           DateTime             @default(now()) @db.Timestamptz(3)
  updatedAt           DateTime             @updatedAt @db.Timestamptz(3)
  vendor              Vendor               @relation(fields: [vendorId], references: [id], onDelete: Restrict)
  items               SettlementItem[]
  reconciliationItems ReconciliationItem[]

  @@unique([provider, providerReference])
  @@index([vendorId, status, createdAt])
  @@index([status, eligibleAt])
}

model SettlementItem {
  id            String            @id @default(uuid()) @db.Uuid
  settlementId  String            @db.Uuid
  ledgerEntryId String            @unique @db.Uuid
  amountMinor   BigInt
  createdAt     DateTime          @default(now()) @db.Timestamptz(3)
  settlement    Settlement        @relation(fields: [settlementId], references: [id], onDelete: Restrict)
  ledgerEntry   VendorLedgerEntry @relation(fields: [ledgerEntryId], references: [id], onDelete: Restrict)

  @@index([settlementId])
}

model Fulfillment {
  id            String            @id @default(uuid()) @db.Uuid
  vendorOrderId String            @unique @db.Uuid
  status        FulfillmentStatus @default(PENDING)
  handledById   String?           @db.Uuid
  packingNotes  String?           @db.Text
  acceptedAt    DateTime?         @db.Timestamptz(3)
  packedAt      DateTime?         @db.Timestamptz(3)
  readyAt       DateTime?         @db.Timestamptz(3)
  createdAt     DateTime          @default(now()) @db.Timestamptz(3)
  updatedAt     DateTime          @updatedAt @db.Timestamptz(3)
  vendorOrder   VendorOrder       @relation(fields: [vendorOrderId], references: [id], onDelete: Restrict)
  handledBy     User?             @relation("FulfillmentHandler", fields: [handledById], references: [id], onDelete: SetNull)
  shipments     Shipment[]

  @@index([status, createdAt])
}

model Shipment {
  id                        String          @id @default(uuid()) @db.Uuid
  vendorOrderId             String          @db.Uuid
  fulfillmentId             String?         @db.Uuid
  returnRequestId           String?         @db.Uuid
  type                      ShipmentType    @default(FORWARD)
  provider                  String          @db.VarChar(80)
  providerShipmentReference String?         @db.VarChar(255)
  awb                       String?         @db.VarChar(120)
  trackingNumber            String?         @db.VarChar(160)
  courierName               String?         @db.VarChar(120)
  status                    ShipmentStatus  @default(CREATED)
  shippingCostMinor         BigInt          @default(0)
  currency                  String          @default("INR") @db.Char(3)
  shippingAddress           Json
  labelUrl                  String?         @db.Text
  idempotencyKey            String          @unique @db.VarChar(180)
  estimatedDeliveryAt       DateTime?       @db.Timestamptz(3)
  pickupScheduledAt         DateTime?       @db.Timestamptz(3)
  shippedAt                 DateTime?       @db.Timestamptz(3)
  deliveredAt               DateTime?       @db.Timestamptz(3)
  cancelledAt               DateTime?       @db.Timestamptz(3)
  metadata                  Json?
  createdAt                 DateTime        @default(now()) @db.Timestamptz(3)
  updatedAt                 DateTime        @updatedAt @db.Timestamptz(3)
  vendorOrder               VendorOrder     @relation(fields: [vendorOrderId], references: [id], onDelete: Restrict)
  fulfillment               Fulfillment?    @relation(fields: [fulfillmentId], references: [id], onDelete: SetNull)
  returnRequest             ReturnRequest?  @relation(fields: [returnRequestId], references: [id], onDelete: SetNull)
  trackingEvents            TrackingEvent[]
  supportCases              SupportCase[]

  @@unique([provider, providerShipmentReference])
  @@index([vendorOrderId, status])
  @@index([returnRequestId])
  @@index([trackingNumber])
  @@index([status, updatedAt])
}

model TrackingEvent {
  id              String         @id @default(uuid()) @db.Uuid
  shipmentId      String         @db.Uuid
  providerEventId String?        @db.VarChar(255)
  status          ShipmentStatus
  description     String?        @db.VarChar(500)
  location        String?        @db.VarChar(255)
  eventAt         DateTime       @db.Timestamptz(3)
  rawPayload      Json?
  createdAt       DateTime       @default(now()) @db.Timestamptz(3)
  shipment        Shipment       @relation(fields: [shipmentId], references: [id], onDelete: Cascade)

  @@unique([shipmentId, providerEventId])
  @@index([shipmentId, eventAt])
}

model ReturnRequest {
  id                 String              @id @default(uuid()) @db.Uuid
  returnNumber       String              @unique @db.VarChar(72)
  marketplaceOrderId String              @db.Uuid
  requestedById      String              @db.Uuid
  reviewedById       String?             @db.Uuid
  status             ReturnRequestStatus @default(REQUESTED)
  reason             String              @db.VarChar(500)
  customerNotes      String?             @db.Text
  reviewNotes        String?             @db.Text
  requestedAt        DateTime            @default(now()) @db.Timestamptz(3)
  reviewedAt         DateTime?           @db.Timestamptz(3)
  receivedAt         DateTime?           @db.Timestamptz(3)
  completedAt        DateTime?           @db.Timestamptz(3)
  createdAt          DateTime            @default(now()) @db.Timestamptz(3)
  updatedAt          DateTime            @updatedAt @db.Timestamptz(3)
  marketplaceOrder   MarketplaceOrder    @relation(fields: [marketplaceOrderId], references: [id], onDelete: Restrict)
  requestedBy        User                @relation("ReturnRequester", fields: [requestedById], references: [id], onDelete: Restrict)
  reviewedBy         User?               @relation("ReturnReviewer", fields: [reviewedById], references: [id], onDelete: SetNull)
  items              ReturnItem[]
  shipments          Shipment[]
  refunds            Refund[]

  @@index([marketplaceOrderId, status])
  @@index([requestedById, createdAt])
  @@index([status, requestedAt])
}

model ReturnItem {
  id               String           @id @default(uuid()) @db.Uuid
  returnRequestId  String           @db.Uuid
  orderItemId      String           @db.Uuid
  quantity         Int
  status           ReturnItemStatus @default(REQUESTED)
  reason           String           @db.VarChar(500)
  conditionNotes   String?          @db.Text
  inspectionResult String?          @db.VarChar(500)
  createdAt        DateTime         @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime         @updatedAt @db.Timestamptz(3)
  returnRequest    ReturnRequest    @relation(fields: [returnRequestId], references: [id], onDelete: Cascade)
  orderItem        OrderItem        @relation(fields: [orderItemId], references: [id], onDelete: Restrict)

  @@unique([returnRequestId, orderItemId])
  @@index([orderItemId])
}

model Refund {
  id                      String               @id @default(uuid()) @db.Uuid
  refundNumber            String               @unique @db.VarChar(72)
  marketplaceOrderId      String               @db.Uuid
  paymentId               String               @db.Uuid
  returnRequestId         String?              @db.Uuid
  requestedById           String               @db.Uuid
  approvedById            String?              @db.Uuid
  status                  RefundStatus         @default(REQUESTED)
  amountMinor             BigInt
  currency                String               @default("INR") @db.Char(3)
  reason                  String               @db.Text
  idempotencyKey          String               @unique @db.VarChar(180)
  providerRefundReference String?              @db.VarChar(255)
  requestedAt             DateTime             @default(now()) @db.Timestamptz(3)
  approvedAt              DateTime?            @db.Timestamptz(3)
  completedAt             DateTime?            @db.Timestamptz(3)
  failedAt                DateTime?            @db.Timestamptz(3)
  failureReason           String?              @db.Text
  createdAt               DateTime             @default(now()) @db.Timestamptz(3)
  updatedAt               DateTime             @updatedAt @db.Timestamptz(3)
  marketplaceOrder        MarketplaceOrder     @relation(fields: [marketplaceOrderId], references: [id], onDelete: Restrict)
  payment                 Payment              @relation(fields: [paymentId], references: [id], onDelete: Restrict)
  returnRequest           ReturnRequest?       @relation(fields: [returnRequestId], references: [id], onDelete: SetNull)
  requestedBy             User                 @relation("RefundRequester", fields: [requestedById], references: [id], onDelete: Restrict)
  approvedBy              User?                @relation("RefundApprover", fields: [approvedById], references: [id], onDelete: SetNull)
  transactions            RefundTransaction[]
  ledgerEntries           VendorLedgerEntry[]
  reconciliationItems     ReconciliationItem[]

  @@unique([paymentId, providerRefundReference])
  @@index([marketplaceOrderId, status])
  @@index([paymentId])
  @@index([returnRequestId])
  @@index([status, requestedAt])
}

model RefundTransaction {
  id                           String                  @id @default(uuid()) @db.Uuid
  refundId                     String                  @db.Uuid
  provider                     String                  @db.VarChar(80)
  providerTransactionReference String?                 @db.VarChar(255)
  status                       RefundTransactionStatus @default(CREATED)
  amountMinor                  BigInt
  currency                     String                  @default("INR") @db.Char(3)
  attemptNumber                Int
  providerResponse             Json?
  errorCode                    String?                 @db.VarChar(100)
  errorMessage                 String?                 @db.Text
  createdAt                    DateTime                @default(now()) @db.Timestamptz(3)
  updatedAt                    DateTime                @updatedAt @db.Timestamptz(3)
  refund                       Refund                  @relation(fields: [refundId], references: [id], onDelete: Cascade)

  @@unique([refundId, attemptNumber])
  @@unique([provider, providerTransactionReference])
  @@index([status, createdAt])
}

model Dispute {
  id                 String                     @id @default(uuid()) @db.Uuid
  disputeNumber      String                     @unique @db.VarChar(72)
  marketplaceOrderId String                     @db.Uuid
  vendorOrderId      String?                    @db.Uuid
  vendorId           String?                    @db.Uuid
  openedById         String                     @db.Uuid
  resolvedById       String?                    @db.Uuid
  type               DisputeType
  status             DisputeStatus              @default(OPEN)
  subject            String                     @db.VarChar(240)
  description        String                     @db.Text
  resolution         String?                    @db.Text
  openedAt           DateTime                   @default(now()) @db.Timestamptz(3)
  resolvedAt         DateTime?                  @db.Timestamptz(3)
  closedAt           DateTime?                  @db.Timestamptz(3)
  createdAt          DateTime                   @default(now()) @db.Timestamptz(3)
  updatedAt          DateTime                   @updatedAt @db.Timestamptz(3)
  marketplaceOrder   MarketplaceOrder           @relation(fields: [marketplaceOrderId], references: [id], onDelete: Restrict)
  vendorOrder        VendorOrder?               @relation(fields: [vendorOrderId], references: [id], onDelete: SetNull)
  vendor             Vendor?                    @relation(fields: [vendorId], references: [id], onDelete: SetNull)
  openedBy           User                       @relation("DisputeOpener", fields: [openedById], references: [id], onDelete: Restrict)
  resolvedBy         User?                      @relation("DisputeResolver", fields: [resolvedById], references: [id], onDelete: SetNull)
  messages           DisputeMessage[]
  evidence           DisputeEvidenceReference[]

  @@index([marketplaceOrderId, status])
  @@index([vendorId, status])
  @@index([openedById, createdAt])
  @@index([status, openedAt])
}

model DisputeMessage {
  id         String                   @id @default(uuid()) @db.Uuid
  disputeId  String                   @db.Uuid
  authorId   String?                  @db.Uuid
  authorType DisputeMessageAuthorType
  message    String                   @db.Text
  isInternal Boolean                  @default(false)
  createdAt  DateTime                 @default(now()) @db.Timestamptz(3)
  dispute    Dispute                  @relation(fields: [disputeId], references: [id], onDelete: Cascade)
  author     User?                    @relation("DisputeMessageAuthor", fields: [authorId], references: [id], onDelete: SetNull)

  @@index([disputeId, createdAt])
}

model DisputeEvidenceReference {
  id               String   @id @default(uuid()) @db.Uuid
  disputeId        String   @db.Uuid
  provider         String   @db.VarChar(80)
  storageReference String   @db.VarChar(500)
  fileName         String?  @db.VarChar(255)
  mimeType         String?  @db.VarChar(120)
  description      String?  @db.VarChar(500)
  metadata         Json?
  createdAt        DateTime @default(now()) @db.Timestamptz(3)
  dispute          Dispute  @relation(fields: [disputeId], references: [id], onDelete: Cascade)

  @@unique([provider, storageReference])
  @@index([disputeId, createdAt])
}

model Review {
  id               String       @id @default(uuid()) @db.Uuid
  customerId       String       @db.Uuid
  orderItemId      String       @db.Uuid
  productId        String?      @db.Uuid
  vendorId         String?      @db.Uuid
  type             ReviewType
  rating           Int
  title            String?      @db.VarChar(200)
  body             String?      @db.Text
  status           ReviewStatus @default(PENDING)
  verifiedPurchase Boolean      @default(true)
  moderatedById    String?      @db.Uuid
  moderationReason String?      @db.Text
  publishedAt      DateTime?    @db.Timestamptz(3)
  createdAt        DateTime     @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime     @updatedAt @db.Timestamptz(3)
  customer         User         @relation("ReviewCustomer", fields: [customerId], references: [id], onDelete: Restrict)
  orderItem        OrderItem    @relation(fields: [orderItemId], references: [id], onDelete: Restrict)
  product          Product?     @relation(fields: [productId], references: [id], onDelete: SetNull)
  vendor           Vendor?      @relation(fields: [vendorId], references: [id], onDelete: SetNull)
  moderatedBy      User?        @relation("ReviewModerator", fields: [moderatedById], references: [id], onDelete: SetNull)

  @@unique([customerId, orderItemId, type])
  @@index([productId, status, createdAt])
  @@index([vendorId, status, createdAt])
  @@index([customerId, createdAt])
}

model Notification {
  id               String                 @id @default(uuid()) @db.Uuid
  userId           String?                @db.Uuid
  eventType        String                 @db.VarChar(160)
  templateKey      String                 @db.VarChar(160)
  subject          String?                @db.VarChar(300)
  payload          Json
  status           NotificationStatus     @default(PENDING)
  scheduledAt      DateTime?              @db.Timestamptz(3)
  sentAt           DateTime?              @db.Timestamptz(3)
  deduplicationKey String?                @unique @db.VarChar(180)
  createdAt        DateTime               @default(now()) @db.Timestamptz(3)
  updatedAt        DateTime               @updatedAt @db.Timestamptz(3)
  user             User?                  @relation(fields: [userId], references: [id], onDelete: SetNull)
  deliveries       NotificationDelivery[]

  @@index([userId, createdAt])
  @@index([status, scheduledAt])
  @@index([eventType, createdAt])
}

model NotificationDelivery {
  id                String                     @id @default(uuid()) @db.Uuid
  notificationId    String                     @db.Uuid
  channel           NotificationChannel
  recipient         String                     @db.VarChar(320)
  provider          String                     @db.VarChar(80)
  providerReference String?                    @db.VarChar(255)
  status            NotificationDeliveryStatus @default(PENDING)
  attemptCount      Int                        @default(0)
  lastAttemptAt     DateTime?                  @db.Timestamptz(3)
  deliveredAt       DateTime?                  @db.Timestamptz(3)
  errorCode         String?                    @db.VarChar(100)
  errorMessage      String?                    @db.Text
  metadata          Json?
  createdAt         DateTime                   @default(now()) @db.Timestamptz(3)
  updatedAt         DateTime                   @updatedAt @db.Timestamptz(3)
  notification      Notification               @relation(fields: [notificationId], references: [id], onDelete: Cascade)

  @@unique([notificationId, channel, recipient])
  @@index([status, createdAt])
  @@index([provider, providerReference])
}

model SupportCase {
  id                 String            @id @default(uuid()) @db.Uuid
  userId             String            @db.Uuid
  marketplaceOrderId String?           @db.Uuid
  paymentId          String?           @db.Uuid
  shipmentId         String?           @db.Uuid
  provider           String?           @db.VarChar(80)
  externalReference  String?           @db.VarChar(255)
  subject            String            @db.VarChar(240)
  description        String?           @db.Text
  status             SupportCaseStatus @default(OPEN)
  priority           SupportPriority   @default(NORMAL)
  createdAt          DateTime          @default(now()) @db.Timestamptz(3)
  updatedAt          DateTime          @updatedAt @db.Timestamptz(3)
  closedAt           DateTime?         @db.Timestamptz(3)
  user               User              @relation(fields: [userId], references: [id], onDelete: Restrict)
  marketplaceOrder   MarketplaceOrder? @relation(fields: [marketplaceOrderId], references: [id], onDelete: SetNull)
  payment            Payment?          @relation(fields: [paymentId], references: [id], onDelete: SetNull)
  shipment           Shipment?         @relation(fields: [shipmentId], references: [id], onDelete: SetNull)

  @@unique([provider, externalReference])
  @@index([userId, status, createdAt])
  @@index([marketplaceOrderId])
  @@index([paymentId])
  @@index([shipmentId])
}

model AuditLog {
  id            String         @id @default(uuid()) @db.Uuid
  actorId       String?        @db.Uuid
  actorType     AuditActorType
  action        String         @db.VarChar(180)
  resourceType  String         @db.VarChar(120)
  resourceId    String         @db.VarChar(120)
  previousState Json?
  newState      Json?
  reason        String?        @db.Text
  requestId     String?        @db.VarChar(120)
  correlationId String?        @db.VarChar(120)
  ipAddress     String?        @db.VarChar(64)
  userAgent     String?        @db.VarChar(512)
  metadata      Json?
  createdAt     DateTime       @default(now()) @db.Timestamptz(3)
  actor         User?          @relation("AuditActor", fields: [actorId], references: [id], onDelete: SetNull)

  @@index([resourceType, resourceId, createdAt])
  @@index([actorId, createdAt])
  @@index([action, createdAt])
  @@index([correlationId])
}

model ReconciliationRun {
  id            String                  @id @default(uuid()) @db.Uuid
  provider      String                  @db.VarChar(80)
  type          ReconciliationType
  status        ReconciliationRunStatus @default(PENDING)
  periodStart   DateTime                @db.Timestamptz(3)
  periodEnd     DateTime                @db.Timestamptz(3)
  startedAt     DateTime?               @db.Timestamptz(3)
  completedAt   DateTime?               @db.Timestamptz(3)
  summary       Json?
  failureReason String?                 @db.Text
  createdAt     DateTime                @default(now()) @db.Timestamptz(3)
  updatedAt     DateTime                @updatedAt @db.Timestamptz(3)
  items         ReconciliationItem[]

  @@unique([provider, type, periodStart, periodEnd])
  @@index([status, createdAt])
}

model ReconciliationItem {
  id                String                   @id @default(uuid()) @db.Uuid
  runId             String                   @db.Uuid
  paymentId         String?                  @db.Uuid
  refundId          String?                  @db.Uuid
  settlementId      String?                  @db.Uuid
  externalReference String                   @db.VarChar(255)
  status            ReconciliationItemStatus
  expectedMinor     BigInt?
  actualMinor       BigInt?
  differenceMinor   BigInt?
  currency          String                   @default("INR") @db.Char(3)
  details           Json?
  resolvedAt        DateTime?                @db.Timestamptz(3)
  resolvedById      String?                  @db.Uuid
  createdAt         DateTime                 @default(now()) @db.Timestamptz(3)
  updatedAt         DateTime                 @updatedAt @db.Timestamptz(3)
  run               ReconciliationRun        @relation(fields: [runId], references: [id], onDelete: Cascade)
  payment           Payment?                 @relation(fields: [paymentId], references: [id], onDelete: SetNull)
  refund            Refund?                  @relation(fields: [refundId], references: [id], onDelete: SetNull)
  settlement        Settlement?              @relation(fields: [settlementId], references: [id], onDelete: SetNull)
  resolvedBy        User?                    @relation("ReconciliationResolver", fields: [resolvedById], references: [id], onDelete: SetNull)

  @@unique([runId, externalReference])
  @@index([status, createdAt])
  @@index([paymentId])
  @@index([refundId])
  @@index([settlementId])
}