@open-mercato/core 0.5.1-develop.2663.2c29774b5b → 0.5.1-develop.2681.c559bb2bc3

package/src/modules/customers/data/entities.ts

@@ -75,6 +75,12 @@ export class CustomerEntity {
   @Property({ name: 'source', type: 'text', nullable: true })
   source?: string | null
 
+  @Property({ name: 'temperature', type: 'text', nullable: true })
+  temperature?: string | null
+
+  @Property({ name: 'renewal_quarter', type: 'text', nullable: true })
+  renewalQuarter?: string | null
+
   @Property({ name: 'next_interaction_at', type: Date, nullable: true })
   nextInteractionAt?: Date | null
 
@@ -132,6 +138,12 @@ export class CustomerEntity {
   @OneToMany(() => CustomerDealCompanyLink, (link) => link.company)
   dealCompanyLinks = new Collection<CustomerDealCompanyLink>(this)
 
+  @OneToMany(() => CustomerPersonCompanyLink, (link) => link.person)
+  personCompanyLinks = new Collection<CustomerPersonCompanyLink>(this)
+
+  @OneToMany(() => CustomerPersonCompanyLink, (link) => link.company)
+  linkedPeople = new Collection<CustomerPersonCompanyLink>(this)
+
   @OneToMany(() => CustomerPersonProfile, (person) => person.company)
   companyMembers = new Collection<CustomerPersonProfile>(this)
 }
@@ -201,6 +213,46 @@ export class CustomerPersonProfile {
   company?: CustomerEntity | null
 }
 
+@Entity({ tableName: 'customer_person_company_links' })
+@Index({ name: 'customer_person_company_links_person_idx', properties: ['person'] })
+@Index({ name: 'customer_person_company_links_company_idx', properties: ['company'] })
+@Index({ name: 'customer_person_company_links_scope_idx', properties: ['organizationId', 'tenantId'] })
+@Index({
+  name: 'customer_person_company_links_active_unique',
+  expression:
+    `create unique index "customer_person_company_links_active_unique" on "customer_person_company_links" ("person_entity_id", "company_entity_id") where "deleted_at" is null`,
+})
+export class CustomerPersonCompanyLink {
+  [OptionalProps]?: 'isPrimary' | 'createdAt' | 'updatedAt' | 'deletedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'is_primary', type: 'boolean', default: false })
+  isPrimary: boolean = false
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+
+  @ManyToOne(() => CustomerEntity, { fieldName: 'person_entity_id' })
+  person!: CustomerEntity
+
+  @ManyToOne(() => CustomerEntity, { fieldName: 'company_entity_id' })
+  company!: CustomerEntity
+}
+
 @Entity({ tableName: 'customer_companies' })
 @Index({ name: 'customer_companies_org_tenant_idx', properties: ['organizationId', 'tenantId'] })
 @Index({
@@ -257,6 +309,10 @@ export class CustomerCompanyProfile {
 
 @Entity({ tableName: 'customer_deals' })
 @Index({ name: 'customer_deals_org_tenant_idx', properties: ['organizationId', 'tenantId'] })
+@Index({
+  name: 'customer_deals_closure_stats_idx',
+  properties: ['organizationId', 'tenantId', 'closureOutcome', 'updatedAt'],
+})
 export class CustomerDeal {
   [OptionalProps]?: 'status' | 'createdAt' | 'updatedAt' | 'deletedAt'
 
@@ -305,6 +361,15 @@ export class CustomerDeal {
   @Property({ name: 'source', type: 'text', nullable: true })
   source?: string | null
 
+  @Property({ name: 'closure_outcome', type: 'text', nullable: true })
+  closureOutcome?: string | null
+
+  @Property({ name: 'loss_reason_id', type: 'uuid', nullable: true })
+  lossReasonId?: string | null
+
+  @Property({ name: 'loss_notes', type: 'text', nullable: true })
+  lossNotes?: string | null
+
   @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
   createdAt: Date = new Date()
 
@@ -325,6 +390,59 @@ export class CustomerDeal {
 
   @OneToMany(() => CustomerComment, (comment) => comment.deal)
   comments = new Collection<CustomerComment>(this)
+
+  @OneToMany(() => CustomerDealStageTransition, (transition) => transition.deal)
+  stageTransitions = new Collection<CustomerDealStageTransition>(this)
+}
+
+@Entity({ tableName: 'customer_deal_stage_transitions' })
+@Index({ name: 'customer_deal_stage_transitions_deal_idx', properties: ['deal'] })
+@Index({ name: 'customer_deal_stage_transitions_org_tenant_idx', properties: ['organizationId', 'tenantId'] })
+@Unique({ name: 'customer_deal_stage_transitions_deal_stage_uq', properties: ['deal', 'stageId'] })
+export class CustomerDealStageTransition {
+  [OptionalProps]?: 'isActive' | 'createdAt' | 'updatedAt' | 'deletedAt' | 'transitionedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'pipeline_id', type: 'uuid' })
+  pipelineId!: string
+
+  @Property({ name: 'stage_id', type: 'uuid' })
+  stageId!: string
+
+  @Property({ name: 'stage_label', type: 'text' })
+  stageLabel!: string
+
+  @Property({ name: 'stage_order', type: 'int' })
+  stageOrder!: number
+
+  @Property({ name: 'transitioned_at', type: Date, onCreate: () => new Date() })
+  transitionedAt: Date = new Date()
+
+  @Property({ name: 'transitioned_by_user_id', type: 'uuid', nullable: true })
+  transitionedByUserId?: string | null
+
+  @Property({ name: 'is_active', type: 'boolean', default: true })
+  isActive: boolean = true
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+
+  @ManyToOne(() => CustomerDeal, { fieldName: 'deal_id' })
+  deal!: CustomerDeal
 }
 
 @Entity({ tableName: 'customer_deal_people' })
@@ -434,7 +552,7 @@ export class CustomerActivity {
   properties: ['tenantId', 'organizationId', 'interactionType'],
 })
 export class CustomerInteraction {
-  [OptionalProps]?: 'status' | 'createdAt' | 'updatedAt' | 'deletedAt'
+  [OptionalProps]?: 'status' | 'pinned' | 'createdAt' | 'updatedAt' | 'deletedAt' | 'durationMinutes' | 'location' | 'allDay' | 'recurrenceRule' | 'recurrenceEnd' | 'participants' | 'reminderMinutes' | 'visibility' | 'linkedEntities' | 'guestPermissions'
 
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
@@ -484,6 +602,39 @@ export class CustomerInteraction {
   @Property({ name: 'deal_id', type: 'uuid', nullable: true })
   dealId?: string | null
 
+  @Property({ name: 'duration_minutes', type: 'int', nullable: true })
+  durationMinutes?: number | null
+
+  @Property({ name: 'location', type: 'text', nullable: true })
+  location?: string | null
+
+  @Property({ name: 'all_day', type: 'boolean', nullable: true })
+  allDay?: boolean | null
+
+  @Property({ name: 'recurrence_rule', type: 'text', nullable: true })
+  recurrenceRule?: string | null
+
+  @Property({ name: 'recurrence_end', type: Date, nullable: true })
+  recurrenceEnd?: Date | null
+
+  @Property({ name: 'participants', type: 'jsonb', nullable: true })
+  participants?: Array<{ userId: string; name?: string; email?: string; status?: string }> | null
+
+  @Property({ name: 'reminder_minutes', type: 'int', nullable: true })
+  reminderMinutes?: number | null
+
+  @Property({ name: 'visibility', type: 'text', nullable: true })
+  visibility?: string | null
+
+  @Property({ name: 'linked_entities', type: 'jsonb', nullable: true })
+  linkedEntities?: Array<{ id: string; type: string; label: string }> | null
+
+  @Property({ name: 'guest_permissions', type: 'jsonb', nullable: true })
+  guestPermissions?: { canInviteOthers?: boolean; canModify?: boolean; canSeeList?: boolean } | null
+
+  @Property({ name: 'pinned', type: 'boolean', default: false })
+  pinned: boolean = false
+
   @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
   createdAt: Date = new Date()
 
@@ -821,3 +972,204 @@ export class CustomerTodoLink {
   @ManyToOne(() => CustomerEntity, { fieldName: 'entity_id' })
   entity!: CustomerEntity
 }
+
+@Entity({ tableName: 'customer_entity_roles' })
+@Index({ name: 'customer_entity_roles_entity_idx', properties: ['entityType', 'entityId'] })
+@Index({ name: 'customer_entity_roles_scope_idx', properties: ['organizationId', 'tenantId'] })
+@Index({
+  name: 'customer_entity_roles_active_unique',
+  expression:
+    'create unique index "customer_entity_roles_active_unique" on "customer_entity_roles" ("entity_type", "entity_id", "role_type") where "deleted_at" is null',
+})
+export class CustomerEntityRole {
+  [OptionalProps]?: 'createdAt' | 'updatedAt' | 'deletedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'entity_type', type: 'text' })
+  entityType!: string
+
+  @Property({ name: 'entity_id', type: 'uuid' })
+  entityId!: string
+
+  @Property({ name: 'user_id', type: 'uuid' })
+  userId!: string
+
+  @Property({ name: 'role_type', type: 'text' })
+  roleType!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onCreate: () => new Date(), onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
+@Entity({ tableName: 'customer_dictionary_kind_settings' })
+@Index({ name: 'customer_dict_kind_settings_scope_idx', properties: ['organizationId', 'tenantId'] })
+@Unique({ name: 'customer_dict_kind_settings_unique', properties: ['organizationId', 'tenantId', 'kind'] })
+export class CustomerDictionaryKindSetting {
+  [OptionalProps]?: 'selectionMode' | 'visibleInTags' | 'sortOrder' | 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ type: 'text' })
+  kind!: string
+
+  @Property({ name: 'selection_mode', type: 'text', default: 'single' })
+  selectionMode: string = 'single'
+
+  @Property({ name: 'visible_in_tags', type: 'boolean', default: true })
+  visibleInTags: boolean = true
+
+  @Property({ name: 'sort_order', type: 'int', default: 0 })
+  sortOrder: number = 0
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+}
+
+@Entity({ tableName: 'customer_labels' })
+@Index({ name: 'customer_labels_scope_idx', properties: ['organizationId', 'tenantId', 'userId'] })
+@Unique({ name: 'customer_labels_unique', properties: ['userId', 'tenantId', 'organizationId', 'slug'] })
+export class CustomerLabel {
+  [OptionalProps]?: 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'user_id', type: 'uuid' })
+  userId!: string
+
+  @Property({ type: 'text' })
+  slug!: string
+
+  @Property({ type: 'text' })
+  label!: string
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+}
+
+@Entity({ tableName: 'customer_label_assignments' })
+@Index({ name: 'customer_label_assignments_entity_idx', properties: ['entity'] })
+@Unique({ name: 'customer_label_assignments_unique', properties: ['label', 'entity'] })
+export class CustomerLabelAssignment {
+  [OptionalProps]?: 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'user_id', type: 'uuid' })
+  userId!: string
+
+  @ManyToOne(() => CustomerLabel, { fieldName: 'label_id' })
+  label!: CustomerLabel
+
+  @ManyToOne(() => CustomerEntity, { fieldName: 'entity_id' })
+  entity!: CustomerEntity
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}
+
+@Entity({ tableName: 'customer_company_billing' })
+@Index({ name: 'customer_company_billing_scope_idx', properties: ['organizationId', 'tenantId'] })
+@Unique({ name: 'customer_company_billing_entity_unique', properties: ['entity'] })
+export class CustomerCompanyBilling {
+  [OptionalProps]?: 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @ManyToOne(() => CustomerEntity, { fieldName: 'entity_id' })
+  entity!: CustomerEntity
+
+  @Property({ name: 'bank_name', type: 'text', nullable: true })
+  bankName?: string | null
+
+  @Property({ name: 'bank_account_masked', type: 'text', nullable: true })
+  bankAccountMasked?: string | null
+
+  @Property({ name: 'payment_terms', type: 'text', nullable: true })
+  paymentTerms?: string | null
+
+  @Property({ name: 'preferred_currency', type: 'text', nullable: true })
+  preferredCurrency?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onCreate: () => new Date(), onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+}
+
+@Entity({ tableName: 'customer_person_company_roles' })
+@Index({ name: 'customer_pcr_scope_idx', properties: ['organizationId', 'tenantId'] })
+@Index({ name: 'customer_pcr_person_company_idx', properties: ['personEntity', 'companyEntity'] })
+@Unique({ name: 'customer_pcr_unique', properties: ['personEntity', 'companyEntity', 'roleValue'] })
+export class CustomerPersonCompanyRole {
+  [OptionalProps]?: 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @ManyToOne(() => CustomerEntity, { fieldName: 'person_entity_id' })
+  personEntity!: CustomerEntity
+
+  @ManyToOne(() => CustomerEntity, { fieldName: 'company_entity_id' })
+  companyEntity!: CustomerEntity
+
+  @Property({ name: 'role_value', type: 'text' })
+  roleValue!: string
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}

package/src/modules/customers/data/validators.ts

@@ -45,6 +45,8 @@ const baseEntitySchema = {
   status: z.string().trim().max(100).optional(),
   lifecycleStage: z.string().trim().max(100).optional(),
   source: z.string().trim().max(150).optional(),
+  temperature: z.string().trim().max(100).optional(),
+  renewalQuarter: z.string().trim().max(100).optional(),
   isActive: z.boolean().optional(),
   nextInteraction: nextInteractionSchema.nullable().optional(),
   tags: z.array(uuid()).optional(),
@@ -120,6 +122,9 @@ export const dealCreateSchema = scopedSchema.extend({
   expectedCloseAt: z.coerce.date().optional(),
   ownerUserId: uuid().optional(),
   source: z.string().max(150).optional(),
+  closureOutcome: z.enum(['won', 'lost']).optional(),
+  lossReasonId: uuid().optional(),
+  lossNotes: z.string().max(4000).optional(),
   companyIds: z.array(uuid()).optional(),
   personIds: z.array(uuid()).optional(),
 })
@@ -214,7 +219,7 @@ export const tagUpdateSchema = z
   })
   .merge(tagCreateSchema.partial())
 
-const dictionaryKindEnum = z.enum([
+const KNOWN_DICTIONARY_KINDS = [
   'status',
   'source',
   'lifecycle_stage',
@@ -224,7 +229,17 @@ const dictionaryKindEnum = z.enum([
   'pipeline_stage',
   'job_title',
   'industry',
-])
+  'temperature',
+  'renewal_quarter',
+  'person_company_role',
+] as const
+const CUSTOM_DICTIONARY_KIND_PATTERN = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/
+const dictionaryKindEnum = z.string().trim().refine(
+  (value) =>
+    (KNOWN_DICTIONARY_KINDS as readonly string[]).includes(value) ||
+    CUSTOM_DICTIONARY_KIND_PATTERN.test(value),
+  { message: 'Unsupported dictionary kind' },
+)
 
 const dictionaryValueSchema = z.string().trim().min(1).max(150)
 const dictionaryLabelSchema = z.string().trim().max(150)
@@ -302,7 +317,41 @@ export const todoLinkWithTodoCreateSchema = scopedSchema.extend({
 export const interactionStatusValues = ['planned', 'done', 'canceled'] as const
 export type InteractionStatus = typeof interactionStatusValues[number]
 
-export const interactionCreateSchema = z.object({
+const interactionParticipantSchema = z.object({
+  userId: z.string().uuid(),
+  name: z.string().trim().max(200).optional(),
+  email: z.string().trim().max(320).optional(),
+  status: z.string().trim().max(50).optional(),
+})
+
+const interactionLinkedEntitySchema = z.object({
+  id: z.string().uuid(),
+  type: z.enum(['company', 'deal', 'offer']),
+  label: z.string().trim().max(500),
+})
+
+const interactionGuestPermissionsSchema = z
+  .object({
+    canInviteOthers: z.boolean().optional(),
+    canModify: z.boolean().optional(),
+    canSeeList: z.boolean().optional(),
+  })
+  .strict()
+
+const interactionExtendedFields = {
+  durationMinutes: z.number().int().min(0).optional().nullable(),
+  location: z.string().trim().max(500).optional().nullable(),
+  allDay: z.boolean().optional().nullable(),
+  recurrenceRule: z.string().trim().max(500).optional().nullable(),
+  recurrenceEnd: z.coerce.date().optional().nullable(),
+  participants: z.array(interactionParticipantSchema).optional().nullable(),
+  reminderMinutes: z.number().int().min(0).optional().nullable(),
+  visibility: z.string().trim().max(50).optional().nullable(),
+  linkedEntities: z.array(interactionLinkedEntitySchema).optional().nullable(),
+  guestPermissions: interactionGuestPermissionsSchema.optional().nullable(),
+} as const
+
+export const interactionCreateSchema = scopedSchema.extend({
   id: z.string().uuid().optional(),
   entityId: z.string().uuid(),
   interactionType: z.string().trim().min(1).max(100),
@@ -318,25 +367,35 @@ export const interactionCreateSchema = z.object({
   appearanceIcon: z.string().trim().max(100).optional().nullable(),
   appearanceColor: z.string().trim().regex(/^#([0-9a-fA-F]{6})$/).optional().nullable(),
   source: z.string().trim().max(100).optional().nullable(),
-}).passthrough()
+  ...interactionExtendedFields,
+})
 
 export type InteractionCreateInput = z.infer<typeof interactionCreateSchema>
 
-export const interactionUpdateSchema = z.object({
-  id: z.string().uuid(),
-  interactionType: z.string().trim().min(1).max(100).optional(),
-  title: z.string().trim().max(500).optional().nullable(),
-  body: z.string().trim().max(10000).optional().nullable(),
-  status: z.enum(interactionStatusValues).optional(),
-  scheduledAt: z.coerce.date().optional().nullable(),
-  occurredAt: z.coerce.date().optional().nullable(),
-  priority: z.number().int().min(0).max(100).optional().nullable(),
-  authorUserId: z.string().uuid().optional().nullable(),
-  ownerUserId: z.string().uuid().optional().nullable(),
-  dealId: z.string().uuid().optional().nullable(),
-  appearanceIcon: z.string().trim().max(100).optional().nullable(),
-  appearanceColor: z.string().trim().regex(/^#([0-9a-fA-F]{6})$/).optional().nullable(),
-}).passthrough()
+export const interactionUpdateSchema = z
+  .object({
+    id: z.string().uuid(),
+  })
+  .merge(
+    scopedSchema
+      .extend({
+        interactionType: z.string().trim().min(1).max(100).optional(),
+        title: z.string().trim().max(500).optional().nullable(),
+        body: z.string().trim().max(10000).optional().nullable(),
+        status: z.enum(interactionStatusValues).optional(),
+        scheduledAt: z.coerce.date().optional().nullable(),
+        occurredAt: z.coerce.date().optional().nullable(),
+        priority: z.number().int().min(0).max(100).optional().nullable(),
+        authorUserId: z.string().uuid().optional().nullable(),
+        ownerUserId: z.string().uuid().optional().nullable(),
+        dealId: z.string().uuid().optional().nullable(),
+        appearanceIcon: z.string().trim().max(100).optional().nullable(),
+        appearanceColor: z.string().trim().regex(/^#([0-9a-fA-F]{6})$/).optional().nullable(),
+        pinned: z.boolean().optional(),
+        ...interactionExtendedFields,
+      })
+      .partial(),
+  )
 
 export type InteractionUpdateInput = z.infer<typeof interactionUpdateSchema>
 
@@ -431,3 +490,95 @@ export type PipelineStageCreateInput = z.infer<typeof pipelineStageCreateSchema>
 export type PipelineStageUpdateInput = z.infer<typeof pipelineStageUpdateSchema>
 export type PipelineStageDeleteInput = z.infer<typeof pipelineStageDeleteSchema>
 export type PipelineStageReorderInput = z.infer<typeof pipelineStageReorderSchema>
+
+export const entityRoleCreateSchema = scopedSchema.extend({
+  entityType: z.enum(['company', 'person']),
+  entityId: uuid(),
+  roleType: z.string().trim().min(1).max(100),
+  userId: uuid(),
+})
+
+export const entityRoleUpdateSchema = scopedSchema.extend({
+  id: uuid(),
+  userId: uuid(),
+})
+
+export const entityRoleDeleteSchema = scopedSchema.extend({
+  id: uuid(),
+})
+
+export type EntityRoleCreateInput = z.infer<typeof entityRoleCreateSchema>
+export type EntityRoleUpdateInput = z.infer<typeof entityRoleUpdateSchema>
+export type EntityRoleDeleteInput = z.infer<typeof entityRoleDeleteSchema>
+
+export const updateKindSettingSchema = z.object({
+  kind: z.string().trim().min(1).max(100),
+  selectionMode: z.enum(['single', 'multi']).optional(),
+  visibleInTags: z.boolean().optional(),
+  sortOrder: z.number().int().min(0).optional(),
+})
+
+export type UpdateKindSettingInput = z.infer<typeof updateKindSettingSchema>
+
+export const customerKindSettingsUpsertSchema = scopedSchema.extend({
+  kind: z.string().trim().min(1).max(100),
+  selectionMode: z.enum(['single', 'multi']).optional(),
+  visibleInTags: z.boolean().optional(),
+  sortOrder: z.number().int().min(0).optional(),
+})
+
+export type CustomerKindSettingsUpsertInput = z.infer<typeof customerKindSettingsUpsertSchema>
+
+export const labelCreateSchema = z.object({
+  label: z.string().trim().min(1).max(120),
+  slug: z.string().trim().min(1).max(80).regex(/^[a-z0-9_-]+$/).optional(),
+})
+
+export type LabelCreateInput = z.infer<typeof labelCreateSchema>
+
+export const labelCreateCommandSchema = scopedSchema.extend({
+  label: z.string().trim().min(1).max(120),
+  slug: z.string().trim().min(1).max(80).regex(/^[a-z0-9_-]+$/),
+  userId: uuid(),
+})
+
+export type LabelCreateCommandInput = z.infer<typeof labelCreateCommandSchema>
+
+export const labelAssignmentSchema = z.object({
+  labelId: z.string().uuid(),
+  entityId: z.string().uuid(),
+})
+
+export type LabelAssignmentInput = z.infer<typeof labelAssignmentSchema>
+
+export const labelAssignCommandSchema = scopedSchema.extend({
+  labelId: uuid(),
+  entityId: uuid(),
+})
+
+export const labelUnassignCommandSchema = scopedSchema.extend({
+  labelId: uuid(),
+  entityId: uuid(),
+})
+
+export type LabelAssignCommandInput = z.infer<typeof labelAssignCommandSchema>
+export type LabelUnassignCommandInput = z.infer<typeof labelUnassignCommandSchema>
+
+export const personCompanyLinkCreateSchema = scopedSchema.extend({
+  personEntityId: uuid(),
+  companyEntityId: uuid(),
+  isPrimary: z.boolean().optional(),
+})
+
+export const personCompanyLinkUpdateSchema = scopedSchema.extend({
+  linkId: uuid(),
+  isPrimary: z.boolean(),
+})
+
+export const personCompanyLinkDeleteSchema = scopedSchema.extend({
+  linkId: uuid(),
+})
+
+export type PersonCompanyLinkCreateInput = z.infer<typeof personCompanyLinkCreateSchema>
+export type PersonCompanyLinkUpdateInput = z.infer<typeof personCompanyLinkUpdateSchema>
+export type PersonCompanyLinkDeleteInput = z.infer<typeof personCompanyLinkDeleteSchema>

package/src/modules/customers/events.ts

@@ -20,6 +20,8 @@ const events = [
   { id: 'customers.deal.created', label: 'Deal Created', entity: 'deal', category: 'crud' },
   { id: 'customers.deal.updated', label: 'Deal Updated', entity: 'deal', category: 'crud' },
   { id: 'customers.deal.deleted', label: 'Deal Deleted', entity: 'deal', category: 'crud' },
+  { id: 'customers.deal.won', label: 'Deal Won', entity: 'deal', category: 'lifecycle' },
+  { id: 'customers.deal.lost', label: 'Deal Lost', entity: 'deal', category: 'lifecycle' },
 
   // Comments
   { id: 'customers.comment.created', label: 'Comment Created', entity: 'comment', category: 'crud' },
@@ -56,6 +58,26 @@ const events = [
   { id: 'customers.interaction.reverted', label: 'Interaction Reverted', entity: 'interaction', category: 'lifecycle' },
   { id: 'customers.interaction.deleted', label: 'Interaction Deleted', entity: 'interaction', category: 'crud' },
   { id: 'customers.next_interaction.updated', label: 'Next Interaction Updated', entity: 'interaction', category: 'lifecycle' },
+
+  // Entity Roles
+  { id: 'customers.entity_role.created', label: 'Entity Role Created', entity: 'entity_role', category: 'crud' },
+  { id: 'customers.entity_role.updated', label: 'Entity Role Updated', entity: 'entity_role', category: 'crud' },
+  { id: 'customers.entity_role.deleted', label: 'Entity Role Deleted', entity: 'entity_role', category: 'crud' },
+
+  // Labels
+  { id: 'customers.label.created', label: 'Label Created', entity: 'label', category: 'crud' },
+  { id: 'customers.label.updated', label: 'Label Updated', entity: 'label', category: 'crud' },
+  { id: 'customers.label.deleted', label: 'Label Deleted', entity: 'label', category: 'crud' },
+
+  // Label Assignments
+  { id: 'customers.label_assignment.created', label: 'Label Assigned', entity: 'label_assignment', category: 'crud' },
+  { id: 'customers.label_assignment.updated', label: 'Label Assignment Updated', entity: 'label_assignment', category: 'crud' },
+  { id: 'customers.label_assignment.deleted', label: 'Label Unassigned', entity: 'label_assignment', category: 'crud' },
+
+  // Person-Company Links
+  { id: 'customers.person_company_link.created', label: 'Person Linked To Company', entity: 'person_company_link', category: 'crud' },
+  { id: 'customers.person_company_link.updated', label: 'Person-Company Link Updated', entity: 'person_company_link', category: 'crud' },
+  { id: 'customers.person_company_link.deleted', label: 'Person Unlinked From Company', entity: 'person_company_link', category: 'crud' },
 ] as const
 
 export const eventsConfig = createModuleEvents({