@contractspec/example.crm-pipeline 1.57.0 → 1.59.0

package/dist/node/entities/contact.entity.js

@@ -0,0 +1,66 @@
+// src/entities/contact.entity.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var ContactStatusEnum = defineEntityEnum({
+  name: "ContactStatus",
+  values: ["LEAD", "PROSPECT", "CUSTOMER", "CHURNED", "ARCHIVED"],
+  schema: "crm",
+  description: "Status of a contact in the sales funnel."
+});
+var ContactEntity = defineEntity({
+  name: "Contact",
+  description: "An individual person in the CRM.",
+  schema: "crm",
+  map: "contact",
+  fields: {
+    id: field.id({ description: "Unique contact ID" }),
+    firstName: field.string({ description: "First name" }),
+    lastName: field.string({ description: "Last name" }),
+    email: field.email({ isOptional: true, isUnique: true }),
+    phone: field.string({ isOptional: true }),
+    companyId: field.string({
+      isOptional: true,
+      description: "Associated company"
+    }),
+    jobTitle: field.string({ isOptional: true }),
+    status: field.enum("ContactStatus", { default: "LEAD" }),
+    organizationId: field.foreignKey(),
+    ownerId: field.foreignKey({
+      description: "Sales rep who owns this contact"
+    }),
+    source: field.string({ isOptional: true, description: "Lead source" }),
+    linkedInUrl: field.url({ isOptional: true }),
+    twitterHandle: field.string({ isOptional: true }),
+    address: field.string({ isOptional: true }),
+    city: field.string({ isOptional: true }),
+    state: field.string({ isOptional: true }),
+    country: field.string({ isOptional: true }),
+    postalCode: field.string({ isOptional: true }),
+    notes: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+    customFields: field.json({ isOptional: true }),
+    lastContactedAt: field.dateTime({ isOptional: true }),
+    nextFollowUpAt: field.dateTime({ isOptional: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    company: field.belongsTo("Company", ["companyId"], ["id"]),
+    deals: field.hasMany("Deal"),
+    tasks: field.hasMany("Task"),
+    activities: field.hasMany("Activity")
+  },
+  indexes: [
+    index.on(["organizationId", "status"]),
+    index.on(["organizationId", "ownerId"]),
+    index.on(["organizationId", "companyId"]),
+    index.on(["email"])
+  ],
+  enums: [ContactStatusEnum]
+});
+export {
+  ContactStatusEnum,
+  ContactEntity
+};

package/dist/node/entities/deal.entity.js

@@ -0,0 +1,107 @@
+// src/entities/deal.entity.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var DealStatusEnum = defineEntityEnum({
+  name: "DealStatus",
+  values: ["OPEN", "WON", "LOST", "STALE"],
+  schema: "crm",
+  description: "Status of a deal."
+});
+var PipelineEntity = defineEntity({
+  name: "Pipeline",
+  description: "A sales pipeline with stages.",
+  schema: "crm",
+  map: "pipeline",
+  fields: {
+    id: field.id(),
+    name: field.string({ description: "Pipeline name" }),
+    description: field.string({ isOptional: true }),
+    organizationId: field.foreignKey(),
+    isDefault: field.boolean({ default: false }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    stages: field.hasMany("Stage"),
+    deals: field.hasMany("Deal")
+  }
+});
+var StageEntity = defineEntity({
+  name: "Stage",
+  description: "A stage within a sales pipeline.",
+  schema: "crm",
+  map: "stage",
+  fields: {
+    id: field.id(),
+    name: field.string({ description: "Stage name" }),
+    pipelineId: field.foreignKey(),
+    position: field.int({ description: "Order in pipeline" }),
+    probability: field.int({
+      default: 0,
+      description: "Win probability (0-100)"
+    }),
+    isWonStage: field.boolean({ default: false }),
+    isLostStage: field.boolean({ default: false }),
+    color: field.string({
+      isOptional: true,
+      description: "Stage color for UI"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    pipeline: field.belongsTo("Pipeline", ["pipelineId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    deals: field.hasMany("Deal")
+  },
+  indexes: [index.on(["pipelineId", "position"])]
+});
+var DealEntity = defineEntity({
+  name: "Deal",
+  description: "A sales opportunity/deal.",
+  schema: "crm",
+  map: "deal",
+  fields: {
+    id: field.id({ description: "Unique deal ID" }),
+    name: field.string({ description: "Deal name" }),
+    value: field.decimal({ description: "Deal value" }),
+    currency: field.string({ default: '"USD"' }),
+    pipelineId: field.foreignKey(),
+    stageId: field.foreignKey(),
+    status: field.enum("DealStatus", { default: "OPEN" }),
+    contactId: field.string({ isOptional: true }),
+    companyId: field.string({ isOptional: true }),
+    organizationId: field.foreignKey(),
+    ownerId: field.foreignKey({ description: "Deal owner" }),
+    expectedCloseDate: field.dateTime({ isOptional: true }),
+    closedAt: field.dateTime({ isOptional: true }),
+    lostReason: field.string({ isOptional: true }),
+    wonSource: field.string({ isOptional: true }),
+    notes: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+    customFields: field.json({ isOptional: true }),
+    stagePosition: field.int({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    pipeline: field.belongsTo("Pipeline", ["pipelineId"], ["id"]),
+    stage: field.belongsTo("Stage", ["stageId"], ["id"]),
+    contact: field.belongsTo("Contact", ["contactId"], ["id"]),
+    company: field.belongsTo("Company", ["companyId"], ["id"]),
+    tasks: field.hasMany("Task"),
+    activities: field.hasMany("Activity")
+  },
+  indexes: [
+    index.on(["organizationId", "status"]),
+    index.on(["pipelineId", "stageId", "stagePosition"]),
+    index.on(["ownerId", "status"]),
+    index.on(["expectedCloseDate"])
+  ],
+  enums: [DealStatusEnum]
+});
+export {
+  StageEntity,
+  PipelineEntity,
+  DealStatusEnum,
+  DealEntity
+};

package/dist/node/entities/index.js

@@ -0,0 +1,343 @@
+// src/entities/company.entity.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var CompanySizeEnum = defineEntityEnum({
+  name: "CompanySize",
+  values: ["STARTUP", "SMALL", "MEDIUM", "LARGE", "ENTERPRISE"],
+  schema: "crm",
+  description: "Size category of a company."
+});
+var CompanyEntity = defineEntity({
+  name: "Company",
+  description: "A company/organization in the CRM.",
+  schema: "crm",
+  map: "company",
+  fields: {
+    id: field.id({ description: "Unique company ID" }),
+    name: field.string({ description: "Company name" }),
+    domain: field.string({ isOptional: true, description: "Website domain" }),
+    website: field.url({ isOptional: true }),
+    industry: field.string({ isOptional: true }),
+    size: field.enum("CompanySize", { isOptional: true }),
+    employeeCount: field.int({ isOptional: true }),
+    annualRevenue: field.decimal({ isOptional: true }),
+    organizationId: field.foreignKey(),
+    ownerId: field.foreignKey({ description: "Account owner" }),
+    phone: field.string({ isOptional: true }),
+    email: field.email({ isOptional: true }),
+    address: field.string({ isOptional: true }),
+    city: field.string({ isOptional: true }),
+    state: field.string({ isOptional: true }),
+    country: field.string({ isOptional: true }),
+    postalCode: field.string({ isOptional: true }),
+    linkedInUrl: field.url({ isOptional: true }),
+    description: field.string({ isOptional: true }),
+    tags: field.string({ isArray: true }),
+    customFields: field.json({ isOptional: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    contacts: field.hasMany("Contact"),
+    deals: field.hasMany("Deal")
+  },
+  indexes: [index.on(["organizationId", "ownerId"]), index.on(["domain"])],
+  enums: [CompanySizeEnum]
+});
+
+// src/entities/contact.entity.ts
+import {
+  defineEntity as defineEntity2,
+  defineEntityEnum as defineEntityEnum2,
+  field as field2,
+  index as index2
+} from "@contractspec/lib.schema";
+var ContactStatusEnum = defineEntityEnum2({
+  name: "ContactStatus",
+  values: ["LEAD", "PROSPECT", "CUSTOMER", "CHURNED", "ARCHIVED"],
+  schema: "crm",
+  description: "Status of a contact in the sales funnel."
+});
+var ContactEntity = defineEntity2({
+  name: "Contact",
+  description: "An individual person in the CRM.",
+  schema: "crm",
+  map: "contact",
+  fields: {
+    id: field2.id({ description: "Unique contact ID" }),
+    firstName: field2.string({ description: "First name" }),
+    lastName: field2.string({ description: "Last name" }),
+    email: field2.email({ isOptional: true, isUnique: true }),
+    phone: field2.string({ isOptional: true }),
+    companyId: field2.string({
+      isOptional: true,
+      description: "Associated company"
+    }),
+    jobTitle: field2.string({ isOptional: true }),
+    status: field2.enum("ContactStatus", { default: "LEAD" }),
+    organizationId: field2.foreignKey(),
+    ownerId: field2.foreignKey({
+      description: "Sales rep who owns this contact"
+    }),
+    source: field2.string({ isOptional: true, description: "Lead source" }),
+    linkedInUrl: field2.url({ isOptional: true }),
+    twitterHandle: field2.string({ isOptional: true }),
+    address: field2.string({ isOptional: true }),
+    city: field2.string({ isOptional: true }),
+    state: field2.string({ isOptional: true }),
+    country: field2.string({ isOptional: true }),
+    postalCode: field2.string({ isOptional: true }),
+    notes: field2.string({ isOptional: true }),
+    tags: field2.string({ isArray: true }),
+    customFields: field2.json({ isOptional: true }),
+    lastContactedAt: field2.dateTime({ isOptional: true }),
+    nextFollowUpAt: field2.dateTime({ isOptional: true }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    company: field2.belongsTo("Company", ["companyId"], ["id"]),
+    deals: field2.hasMany("Deal"),
+    tasks: field2.hasMany("Task"),
+    activities: field2.hasMany("Activity")
+  },
+  indexes: [
+    index2.on(["organizationId", "status"]),
+    index2.on(["organizationId", "ownerId"]),
+    index2.on(["organizationId", "companyId"]),
+    index2.on(["email"])
+  ],
+  enums: [ContactStatusEnum]
+});
+
+// src/entities/deal.entity.ts
+import {
+  defineEntity as defineEntity3,
+  defineEntityEnum as defineEntityEnum3,
+  field as field3,
+  index as index3
+} from "@contractspec/lib.schema";
+var DealStatusEnum = defineEntityEnum3({
+  name: "DealStatus",
+  values: ["OPEN", "WON", "LOST", "STALE"],
+  schema: "crm",
+  description: "Status of a deal."
+});
+var PipelineEntity = defineEntity3({
+  name: "Pipeline",
+  description: "A sales pipeline with stages.",
+  schema: "crm",
+  map: "pipeline",
+  fields: {
+    id: field3.id(),
+    name: field3.string({ description: "Pipeline name" }),
+    description: field3.string({ isOptional: true }),
+    organizationId: field3.foreignKey(),
+    isDefault: field3.boolean({ default: false }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    stages: field3.hasMany("Stage"),
+    deals: field3.hasMany("Deal")
+  }
+});
+var StageEntity = defineEntity3({
+  name: "Stage",
+  description: "A stage within a sales pipeline.",
+  schema: "crm",
+  map: "stage",
+  fields: {
+    id: field3.id(),
+    name: field3.string({ description: "Stage name" }),
+    pipelineId: field3.foreignKey(),
+    position: field3.int({ description: "Order in pipeline" }),
+    probability: field3.int({
+      default: 0,
+      description: "Win probability (0-100)"
+    }),
+    isWonStage: field3.boolean({ default: false }),
+    isLostStage: field3.boolean({ default: false }),
+    color: field3.string({
+      isOptional: true,
+      description: "Stage color for UI"
+    }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    pipeline: field3.belongsTo("Pipeline", ["pipelineId"], ["id"], {
+      onDelete: "Cascade"
+    }),
+    deals: field3.hasMany("Deal")
+  },
+  indexes: [index3.on(["pipelineId", "position"])]
+});
+var DealEntity = defineEntity3({
+  name: "Deal",
+  description: "A sales opportunity/deal.",
+  schema: "crm",
+  map: "deal",
+  fields: {
+    id: field3.id({ description: "Unique deal ID" }),
+    name: field3.string({ description: "Deal name" }),
+    value: field3.decimal({ description: "Deal value" }),
+    currency: field3.string({ default: '"USD"' }),
+    pipelineId: field3.foreignKey(),
+    stageId: field3.foreignKey(),
+    status: field3.enum("DealStatus", { default: "OPEN" }),
+    contactId: field3.string({ isOptional: true }),
+    companyId: field3.string({ isOptional: true }),
+    organizationId: field3.foreignKey(),
+    ownerId: field3.foreignKey({ description: "Deal owner" }),
+    expectedCloseDate: field3.dateTime({ isOptional: true }),
+    closedAt: field3.dateTime({ isOptional: true }),
+    lostReason: field3.string({ isOptional: true }),
+    wonSource: field3.string({ isOptional: true }),
+    notes: field3.string({ isOptional: true }),
+    tags: field3.string({ isArray: true }),
+    customFields: field3.json({ isOptional: true }),
+    stagePosition: field3.int({ default: 0 }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    pipeline: field3.belongsTo("Pipeline", ["pipelineId"], ["id"]),
+    stage: field3.belongsTo("Stage", ["stageId"], ["id"]),
+    contact: field3.belongsTo("Contact", ["contactId"], ["id"]),
+    company: field3.belongsTo("Company", ["companyId"], ["id"]),
+    tasks: field3.hasMany("Task"),
+    activities: field3.hasMany("Activity")
+  },
+  indexes: [
+    index3.on(["organizationId", "status"]),
+    index3.on(["pipelineId", "stageId", "stagePosition"]),
+    index3.on(["ownerId", "status"]),
+    index3.on(["expectedCloseDate"])
+  ],
+  enums: [DealStatusEnum]
+});
+
+// src/entities/task.entity.ts
+import {
+  defineEntity as defineEntity4,
+  defineEntityEnum as defineEntityEnum4,
+  field as field4,
+  index as index4
+} from "@contractspec/lib.schema";
+var TaskTypeEnum = defineEntityEnum4({
+  name: "TaskType",
+  values: ["CALL", "EMAIL", "MEETING", "TODO", "FOLLOW_UP", "OTHER"],
+  schema: "crm",
+  description: "Type of CRM task."
+});
+var TaskPriorityEnum = defineEntityEnum4({
+  name: "TaskPriority",
+  values: ["LOW", "NORMAL", "HIGH", "URGENT"],
+  schema: "crm",
+  description: "Priority of a task."
+});
+var TaskStatusEnum = defineEntityEnum4({
+  name: "TaskStatus",
+  values: ["PENDING", "IN_PROGRESS", "COMPLETED", "CANCELLED"],
+  schema: "crm",
+  description: "Status of a task."
+});
+var TaskEntity = defineEntity4({
+  name: "Task",
+  description: "A task or follow-up activity.",
+  schema: "crm",
+  map: "task",
+  fields: {
+    id: field4.id(),
+    title: field4.string({ description: "Task title" }),
+    description: field4.string({ isOptional: true }),
+    type: field4.enum("TaskType", { default: "TODO" }),
+    priority: field4.enum("TaskPriority", { default: "NORMAL" }),
+    status: field4.enum("TaskStatus", { default: "PENDING" }),
+    dueDate: field4.dateTime({ isOptional: true }),
+    reminderAt: field4.dateTime({ isOptional: true }),
+    contactId: field4.string({ isOptional: true }),
+    dealId: field4.string({ isOptional: true }),
+    companyId: field4.string({ isOptional: true }),
+    organizationId: field4.foreignKey(),
+    assignedTo: field4.foreignKey({ description: "User assigned to this task" }),
+    createdBy: field4.foreignKey(),
+    completedAt: field4.dateTime({ isOptional: true }),
+    completedBy: field4.string({ isOptional: true }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    contact: field4.belongsTo("Contact", ["contactId"], ["id"]),
+    deal: field4.belongsTo("Deal", ["dealId"], ["id"]),
+    company: field4.belongsTo("Company", ["companyId"], ["id"])
+  },
+  indexes: [
+    index4.on(["organizationId", "assignedTo", "status"]),
+    index4.on(["dueDate", "status"]),
+    index4.on(["contactId"]),
+    index4.on(["dealId"])
+  ],
+  enums: [TaskTypeEnum, TaskPriorityEnum, TaskStatusEnum]
+});
+var ActivityEntity = defineEntity4({
+  name: "Activity",
+  description: "An activity/interaction logged in the CRM.",
+  schema: "crm",
+  map: "activity",
+  fields: {
+    id: field4.id(),
+    type: field4.enum("TaskType"),
+    subject: field4.string(),
+    description: field4.string({ isOptional: true }),
+    contactId: field4.string({ isOptional: true }),
+    dealId: field4.string({ isOptional: true }),
+    companyId: field4.string({ isOptional: true }),
+    organizationId: field4.foreignKey(),
+    performedBy: field4.foreignKey(),
+    outcome: field4.string({ isOptional: true }),
+    occurredAt: field4.dateTime(),
+    duration: field4.int({
+      isOptional: true,
+      description: "Duration in minutes"
+    }),
+    createdAt: field4.createdAt(),
+    contact: field4.belongsTo("Contact", ["contactId"], ["id"]),
+    deal: field4.belongsTo("Deal", ["dealId"], ["id"]),
+    company: field4.belongsTo("Company", ["companyId"], ["id"])
+  },
+  indexes: [
+    index4.on(["contactId", "occurredAt"]),
+    index4.on(["dealId", "occurredAt"])
+  ]
+});
+// src/entities/index.ts
+var crmPipelineSchemaContribution = {
+  moduleId: "@contractspec/example.crm-pipeline",
+  entities: [
+    CompanyEntity,
+    ContactEntity,
+    DealEntity,
+    PipelineEntity,
+    StageEntity,
+    TaskEntity,
+    ActivityEntity
+  ],
+  enums: [
+    CompanySizeEnum,
+    ContactStatusEnum,
+    DealStatusEnum,
+    TaskTypeEnum,
+    TaskPriorityEnum,
+    TaskStatusEnum
+  ]
+};
+export {
+  crmPipelineSchemaContribution,
+  TaskTypeEnum,
+  TaskStatusEnum,
+  TaskPriorityEnum,
+  TaskEntity,
+  StageEntity,
+  PipelineEntity,
+  DealStatusEnum,
+  DealEntity,
+  ContactStatusEnum,
+  ContactEntity,
+  CompanySizeEnum,
+  CompanyEntity,
+  ActivityEntity
+};

package/dist/node/entities/task.entity.js

@@ -0,0 +1,99 @@
+// src/entities/task.entity.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var TaskTypeEnum = defineEntityEnum({
+  name: "TaskType",
+  values: ["CALL", "EMAIL", "MEETING", "TODO", "FOLLOW_UP", "OTHER"],
+  schema: "crm",
+  description: "Type of CRM task."
+});
+var TaskPriorityEnum = defineEntityEnum({
+  name: "TaskPriority",
+  values: ["LOW", "NORMAL", "HIGH", "URGENT"],
+  schema: "crm",
+  description: "Priority of a task."
+});
+var TaskStatusEnum = defineEntityEnum({
+  name: "TaskStatus",
+  values: ["PENDING", "IN_PROGRESS", "COMPLETED", "CANCELLED"],
+  schema: "crm",
+  description: "Status of a task."
+});
+var TaskEntity = defineEntity({
+  name: "Task",
+  description: "A task or follow-up activity.",
+  schema: "crm",
+  map: "task",
+  fields: {
+    id: field.id(),
+    title: field.string({ description: "Task title" }),
+    description: field.string({ isOptional: true }),
+    type: field.enum("TaskType", { default: "TODO" }),
+    priority: field.enum("TaskPriority", { default: "NORMAL" }),
+    status: field.enum("TaskStatus", { default: "PENDING" }),
+    dueDate: field.dateTime({ isOptional: true }),
+    reminderAt: field.dateTime({ isOptional: true }),
+    contactId: field.string({ isOptional: true }),
+    dealId: field.string({ isOptional: true }),
+    companyId: field.string({ isOptional: true }),
+    organizationId: field.foreignKey(),
+    assignedTo: field.foreignKey({ description: "User assigned to this task" }),
+    createdBy: field.foreignKey(),
+    completedAt: field.dateTime({ isOptional: true }),
+    completedBy: field.string({ isOptional: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    contact: field.belongsTo("Contact", ["contactId"], ["id"]),
+    deal: field.belongsTo("Deal", ["dealId"], ["id"]),
+    company: field.belongsTo("Company", ["companyId"], ["id"])
+  },
+  indexes: [
+    index.on(["organizationId", "assignedTo", "status"]),
+    index.on(["dueDate", "status"]),
+    index.on(["contactId"]),
+    index.on(["dealId"])
+  ],
+  enums: [TaskTypeEnum, TaskPriorityEnum, TaskStatusEnum]
+});
+var ActivityEntity = defineEntity({
+  name: "Activity",
+  description: "An activity/interaction logged in the CRM.",
+  schema: "crm",
+  map: "activity",
+  fields: {
+    id: field.id(),
+    type: field.enum("TaskType"),
+    subject: field.string(),
+    description: field.string({ isOptional: true }),
+    contactId: field.string({ isOptional: true }),
+    dealId: field.string({ isOptional: true }),
+    companyId: field.string({ isOptional: true }),
+    organizationId: field.foreignKey(),
+    performedBy: field.foreignKey(),
+    outcome: field.string({ isOptional: true }),
+    occurredAt: field.dateTime(),
+    duration: field.int({
+      isOptional: true,
+      description: "Duration in minutes"
+    }),
+    createdAt: field.createdAt(),
+    contact: field.belongsTo("Contact", ["contactId"], ["id"]),
+    deal: field.belongsTo("Deal", ["dealId"], ["id"]),
+    company: field.belongsTo("Company", ["companyId"], ["id"])
+  },
+  indexes: [
+    index.on(["contactId", "occurredAt"]),
+    index.on(["dealId", "occurredAt"])
+  ]
+});
+export {
+  TaskTypeEnum,
+  TaskStatusEnum,
+  TaskPriorityEnum,
+  TaskEntity,
+  ActivityEntity
+};

package/dist/node/events/contact.event.js

@@ -0,0 +1,31 @@
+// src/events/contact.event.ts
+import { ScalarTypeEnum, defineSchemaModel } from "@contractspec/lib.schema";
+import { defineEvent } from "@contractspec/lib.contracts";
+var ContactCreatedPayload = defineSchemaModel({
+  name: "ContactCreatedPayload",
+  description: "Payload when a contact is created",
+  fields: {
+    contactId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    email: { type: ScalarTypeEnum.EmailAddress(), isOptional: true },
+    organizationId: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var ContactCreatedEvent = defineEvent({
+  meta: {
+    key: "contact.created",
+    version: "1.0.0",
+    description: "A new contact has been created.",
+    stability: "stable",
+    owners: ["@crm-team"],
+    tags: ["contact", "created"]
+  },
+  payload: ContactCreatedPayload
+});
+export {
+  ContactCreatedEvent
+};