@fesmex/models 0.1.15 → 0.1.20

package/dist/index.cjs

@@ -0,0 +1,757 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Announcement: () => Announcements_default,
+  Article: () => Article_default,
+  ArticleClass: () => ArticleClasses_default,
+  ArticleGroup: () => ArticleGroups_default,
+  ArticlePrice: () => ArticlePrices_default,
+  Client: () => Clients_default,
+  ClientAddress: () => ClientsAddress_default,
+  ClientContact: () => ClientsContact_default,
+  ClientPaymentMethod: () => ClientsPaymentMethod_default,
+  ClientPaymentTerm: () => ClientsPaymentTerm_default,
+  ClientPriceList: () => ClientsPriceList_default,
+  ClientSalesEmployee: () => ClientsSalesEmployee_default,
+  CreatedMethod: () => CreatedMethod,
+  Currency: () => Currencies_default,
+  Customer: () => Customers_default,
+  FiscalProfile: () => FiscalProfileType_default,
+  InventoryStock: () => InventoryStocks_default,
+  Order: () => Orders_default,
+  OrderStatus: () => OrderStatus,
+  OrderStatusLog: () => OrderStatusLogs_default,
+  PriceList: () => PriceLists_default,
+  Quote: () => Quote_default,
+  QuoteArticle: () => QuoteArticle_default,
+  QuoteArticleExtra: () => QuoteArticleExtra_default,
+  QuoteContact: () => QuoteContact_default,
+  QuoteStatus: () => QuoteStatus,
+  QuoteTerm: () => QuoteTerm_default,
+  Status: () => Status,
+  SyncLog: () => SyncLog,
+  SyncLogAction: () => SyncLogAction,
+  SyncLogStatus: () => SyncLogStatus,
+  SyncLogType: () => SyncLogType,
+  UserRole: () => UserRole,
+  UserStatus: () => UserStatus,
+  Users: () => Users_default,
+  Warehouse: () => Warehouses_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/clients/models/Clients.ts
+var import_mongoose = require("mongoose");
+var clientSchema = new import_mongoose.Schema(
+  {
+    sn_code: { type: String, index: true },
+    sn_name: { type: String, required: true },
+    tax_id: { type: String },
+    currency: { type: String },
+    phone_1: { type: String },
+    email: { type: String },
+    comments: { type: String },
+    pipedrive_id: { type: String },
+    sap_id: { type: String },
+    deleted_at: { type: Date, default: null },
+    deleted_by: { type: String, default: null }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var Clients_default = import_mongoose.models.Client || (0, import_mongoose.model)("Client", clientSchema, "clients");
+
+// src/clients/models/ClientsContact.ts
+var import_mongoose2 = require("mongoose");
+var clientContactSchema = new import_mongoose2.Schema(
+  {
+    client_id: {
+      type: import_mongoose2.Schema.Types.ObjectId,
+      ref: "Client",
+      required: true,
+      index: true
+    },
+    contact_person_name: { type: String },
+    first_name: { type: String },
+    last_name: { type: String },
+    contact_phone: { type: String },
+    contact_email: { type: String },
+    pipedrive_id: { type: String }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var ClientsContact_default = import_mongoose2.models.ClientContact || (0, import_mongoose2.model)("ClientContact", clientContactSchema, "client_contacts");
+
+// src/clients/models/ClientsAddress.ts
+var import_mongoose3 = require("mongoose");
+var clientAddressSchema = new import_mongoose3.Schema(
+  {
+    client_id: {
+      type: import_mongoose3.Schema.Types.ObjectId,
+      ref: "Client",
+      required: true,
+      index: true
+    },
+    address_name: { type: String },
+    street: { type: String },
+    neighborhood: { type: String },
+    postal_code: { type: String },
+    city: { type: String },
+    state: { type: String },
+    country: { type: String }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var ClientsAddress_default = import_mongoose3.models.ClientAddress || (0, import_mongoose3.model)(
+  "ClientAddress",
+  clientAddressSchema,
+  "client_addresses"
+);
+
+// src/clients/models/ClientsPaymentMethod.ts
+var import_mongoose4 = require("mongoose");
+var clientPaymentMethodSchema = new import_mongoose4.Schema(
+  {
+    client_id: {
+      type: import_mongoose4.Schema.Types.ObjectId,
+      ref: "Client",
+      required: true,
+      unique: true
+    },
+    code: { type: String },
+    description: { type: String }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var ClientsPaymentMethod_default = import_mongoose4.models.ClientPaymentMethod || (0, import_mongoose4.model)(
+  "ClientPaymentMethod",
+  clientPaymentMethodSchema,
+  "client_payment_methods"
+);
+
+// src/clients/models/ClientsPaymentTerm.ts
+var import_mongoose5 = require("mongoose");
+var clientPaymentTermSchema = new import_mongoose5.Schema(
+  {
+    client_id: {
+      type: import_mongoose5.Schema.Types.ObjectId,
+      ref: "Client",
+      required: true,
+      unique: true
+    },
+    code: { type: String },
+    name: { type: String }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var ClientsPaymentTerm_default = import_mongoose5.models.ClientPaymentTerm || (0, import_mongoose5.model)(
+  "ClientPaymentTerm",
+  clientPaymentTermSchema,
+  "client_payment_terms"
+);
+
+// src/clients/models/ClientsPriceList.ts
+var import_mongoose6 = require("mongoose");
+var clientPriceListSchema = new import_mongoose6.Schema(
+  {
+    client_id: {
+      type: import_mongoose6.Schema.Types.ObjectId,
+      ref: "Client",
+      required: true,
+      unique: true
+    },
+    number: { type: String },
+    name: { type: String }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var ClientsPriceList_default = import_mongoose6.models.ClientPriceList || (0, import_mongoose6.model)(
+  "ClientPriceList",
+  clientPriceListSchema,
+  "client_price_lists"
+);
+
+// src/clients/models/ClientsSalesEmployee.ts
+var import_mongoose7 = require("mongoose");
+var clientSalesEmployeeSchema = new import_mongoose7.Schema(
+  {
+    client_id: {
+      type: import_mongoose7.Schema.Types.ObjectId,
+      ref: "Client",
+      required: true,
+      unique: true
+    },
+    employee_code: { type: String },
+    employee_name: { type: String }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var ClientsSalesEmployee_default = import_mongoose7.models.ClientSalesEmployee || (0, import_mongoose7.model)(
+  "ClientSalesEmployee",
+  clientSalesEmployeeSchema,
+  "client_sales_employees"
+);
+
+// src/inventory/models/Article.ts
+var import_mongoose8 = require("mongoose");
+var articleSchema = new import_mongoose8.Schema({
+  article_number: { type: String, required: true, unique: true },
+  // SAP ItemCode
+  description: { type: String, required: true },
+  unit: { type: String, required: true },
+  brand: { type: String },
+  model: { type: String },
+  group_id: { type: import_mongoose8.Types.ObjectId, ref: "ArticleGroup", required: true },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date }
+});
+var Article_default = import_mongoose8.models.Article || (0, import_mongoose8.model)("Article", articleSchema, "articles");
+
+// src/inventory/models/ArticleGroups.ts
+var import_mongoose9 = require("mongoose");
+var articleGroupSchema = new import_mongoose9.Schema({
+  name: { type: String, required: true },
+  description: { type: String }
+});
+var ArticleGroups_default = import_mongoose9.models.ArticleGroup || (0, import_mongoose9.model)("ArticleGroup", articleGroupSchema, "article_groups");
+
+// src/inventory/models/ArticleClasses.ts
+var import_mongoose10 = require("mongoose");
+var articleClassSchema = new import_mongoose10.Schema({
+  name: { type: String, required: true },
+  description: { type: String }
+});
+var ArticleClasses_default = import_mongoose10.models.ArticleClass || (0, import_mongoose10.model)("ArticleClass", articleClassSchema, "article_classes");
+
+// src/inventory/models/ArticlePrices.ts
+var import_mongoose11 = require("mongoose");
+var articlePriceSchema = new import_mongoose11.Schema({
+  article_id: { type: import_mongoose11.Types.ObjectId, ref: "Article", required: true },
+  price_list_id: { type: import_mongoose11.Types.ObjectId, ref: "PriceList", required: true },
+  currency_id: { type: import_mongoose11.Types.ObjectId, ref: "Currency", required: true },
+  price: { type: Number, required: true },
+  valid_from: { type: Date },
+  valid_to: { type: Date },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date }
+});
+var ArticlePrices_default = import_mongoose11.models.ArticlePrice || (0, import_mongoose11.model)("ArticlePrice", articlePriceSchema, "article_prices");
+
+// src/inventory/models/Currencies.ts
+var import_mongoose12 = require("mongoose");
+var currencySchema = new import_mongoose12.Schema({
+  code: { type: String, required: true, unique: true },
+  symbol: { type: String, required: true },
+  name: { type: String, required: true }
+});
+var Currencies_default = import_mongoose12.models.Currency || (0, import_mongoose12.model)("Currency", currencySchema, "currencies");
+
+// src/inventory/models/Warehouses.ts
+var import_mongoose13 = require("mongoose");
+var warehouseSchema = new import_mongoose13.Schema({
+  code: { type: String, required: true, unique: true },
+  name: { type: String, required: true },
+  location: { type: String },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date }
+});
+var Warehouses_default = import_mongoose13.models.Warehouse || (0, import_mongoose13.model)("Warehouse", warehouseSchema, "warehouses");
+
+// src/inventory/models/InventoryStocks.ts
+var import_mongoose14 = require("mongoose");
+var inventoryStockSchema = new import_mongoose14.Schema({
+  article_id: { type: import_mongoose14.Types.ObjectId, ref: "Article", required: true },
+  warehouse_id: { type: import_mongoose14.Types.ObjectId, ref: "Warehouse", required: true },
+  count: { type: Number, required: true },
+  min_stock: { type: Number },
+  max_stock: { type: Number },
+  updated_at: { type: Date, default: Date.now }
+});
+var InventoryStocks_default = import_mongoose14.models.InventoryStock || (0, import_mongoose14.model)("InventoryStock", inventoryStockSchema, "inventory_stocks");
+
+// src/inventory/models/PriceLists.ts
+var import_mongoose15 = require("mongoose");
+var priceListSchema = new import_mongoose15.Schema({
+  number: { type: String, required: true, unique: true },
+  name: { type: String, required: true },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date }
+});
+var PriceLists_default = import_mongoose15.models.PriceList || (0, import_mongoose15.model)("PriceList", priceListSchema, "price_lists");
+
+// src/quotes/models/Quote.ts
+var import_mongoose16 = require("mongoose");
+var QuoteStatus = /* @__PURE__ */ ((QuoteStatus2) => {
+  QuoteStatus2["OPPORTUNITY"] = "OPPORTUNITY";
+  QuoteStatus2["QUOTE"] = "QUOTE";
+  QuoteStatus2["FOLLOWING"] = "FOLLOWING";
+  QuoteStatus2["NEGOTIATION"] = "NEGOTIATION";
+  return QuoteStatus2;
+})(QuoteStatus || {});
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["OPEN"] = "OPEN";
+  Status2["WIN"] = "WIN";
+  Status2["LOST"] = "LOST";
+  Status2["DELETE"] = "DELETE";
+  return Status2;
+})(Status || {});
+var CreatedMethod = /* @__PURE__ */ ((CreatedMethod2) => {
+  CreatedMethod2["MANUAL"] = "MANUAL";
+  CreatedMethod2["CSV"] = "CSV";
+  return CreatedMethod2;
+})(CreatedMethod || {});
+var quoteSchema = new import_mongoose16.Schema(
+  {
+    quote_number: { type: Number, required: true },
+    quote_revision: { type: Number, default: 0 },
+    quote_ref: { type: String },
+    company: { type: String },
+    company_id: { type: import_mongoose16.Schema.Types.ObjectId, ref: "Client", required: true },
+    company_pipedrive_id: { type: String },
+    contact_id: { type: import_mongoose16.Schema.Types.ObjectId, ref: "ClientContact" },
+    project_name: { type: String },
+    project_lab: { type: String },
+    payment_condition: { type: String },
+    payment_exp: { type: String },
+    terms_ids: [{ type: import_mongoose16.Schema.Types.ObjectId, ref: "QuoteTerm" }],
+    currency_id: { type: import_mongoose16.Schema.Types.ObjectId, ref: "Currency" },
+    iva: { type: String },
+    date: { type: Date },
+    status: { type: String, enum: Object.values(Status), default: "OPEN" /* OPEN */ },
+    quote_status: {
+      type: String,
+      enum: Object.values(QuoteStatus),
+      default: "OPPORTUNITY" /* OPPORTUNITY */
+    },
+    sap_id: { type: String },
+    sap_quotation_entry: { type: Number },
+    sap_order_entry: { type: Number },
+    pipedrive_id: { type: String },
+    should_sync: { type: Boolean, default: false },
+    pdf_download_link: { type: String },
+    notes: { type: String },
+    created_method: {
+      type: String,
+      enum: Object.values(CreatedMethod),
+      default: "MANUAL" /* MANUAL */
+    },
+    created_by: { type: import_mongoose16.Schema.Types.ObjectId, ref: "User" },
+    updated_by: { type: import_mongoose16.Schema.Types.ObjectId, ref: "User" },
+    deleted_by: { type: import_mongoose16.Schema.Types.ObjectId, ref: "User" },
+    deleted_at: { type: Date }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var Quote_default = import_mongoose16.models.Quote || (0, import_mongoose16.model)("Quote", quoteSchema, "quotes");
+
+// src/quotes/models/QuoteArticle.ts
+var import_mongoose17 = require("mongoose");
+var quoteArticleSchema = new import_mongoose17.Schema(
+  {
+    quote_id: { type: import_mongoose17.Schema.Types.ObjectId, ref: "Quote", required: true },
+    article_id: { type: import_mongoose17.Schema.Types.ObjectId, ref: "Article" },
+    article_number: { type: String },
+    description: { type: String },
+    delivery: { type: String },
+    quantity: { type: Number },
+    price: { type: Number },
+    unit_price: { type: Number },
+    original_price: { type: Number },
+    total: { type: Number },
+    utility: { type: Number },
+    type: { type: String },
+    extra_id: { type: import_mongoose17.Schema.Types.ObjectId, ref: "QuoteArticleExtra" }
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var QuoteArticle_default = import_mongoose17.models.QuoteArticle || (0, import_mongoose17.model)("QuoteArticle", quoteArticleSchema, "quote_articles");
+
+// src/quotes/models/QuoteArticleExtra.ts
+var import_mongoose18 = require("mongoose");
+var quoteArticleExtraSchema = new import_mongoose18.Schema(
+  {
+    quote_article_id: {
+      type: import_mongoose18.Schema.Types.ObjectId,
+      ref: "QuoteArticle",
+      required: true
+    },
+    multiplier: Number,
+    usa_freight: Number,
+    usa_expenses: Number,
+    duty: Number,
+    mex_freight: Number
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var QuoteArticleExtra_default = import_mongoose18.models.QuoteArticleExtra || (0, import_mongoose18.model)("QuoteArticleExtra", quoteArticleExtraSchema, "quote_article_extras");
+
+// src/quotes/models/QuoteContact.ts
+var import_mongoose19 = require("mongoose");
+var quoteContactSchema = new import_mongoose19.Schema({
+  quote_id: { type: import_mongoose19.Schema.Types.ObjectId, ref: "Quote", required: true },
+  name: String,
+  email: String,
+  mobile: String,
+  pipedrive_id: String,
+  created_at: { type: Date, default: Date.now }
+});
+var QuoteContact_default = import_mongoose19.models.QuoteContact || (0, import_mongoose19.model)("QuoteContact", quoteContactSchema, "quote_contacts");
+
+// src/quotes/models/QuoteTerm.ts
+var import_mongoose20 = require("mongoose");
+var quoteTermSchema = new import_mongoose20.Schema(
+  {
+    title: String,
+    content: { type: String, required: true },
+    category: String,
+    is_active: { type: Boolean, default: true },
+    created_by: String,
+    updated_by: String
+  },
+  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } }
+);
+var QuoteTerm_default = import_mongoose20.models.QuoteTerm || (0, import_mongoose20.model)("QuoteTerm", quoteTermSchema, "quote_terms");
+
+// src/customers/models/Customers.ts
+var import_mongoose21 = require("mongoose");
+var import_bcryptjs = __toESM(require("bcryptjs"), 1);
+var CustomerStatus = /* @__PURE__ */ ((CustomerStatus2) => {
+  CustomerStatus2["ACTIVE"] = "active";
+  CustomerStatus2["INACTIVE"] = "inactive";
+  CustomerStatus2["BANNED"] = "banned";
+  return CustomerStatus2;
+})(CustomerStatus || {});
+var customerSchema = new import_mongoose21.Schema({
+  first_name: { type: String, required: true },
+  last_name: { type: String, required: true },
+  email: { type: String, required: true, unique: true },
+  mobile: { type: String },
+  password: { type: String, required: true, select: false },
+  status: {
+    type: String,
+    enum: Object.values(CustomerStatus),
+    default: "active" /* ACTIVE */
+  },
+  fiscal_profile_id: { type: import_mongoose21.Schema.Types.ObjectId, ref: "FiscalProfile" },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date },
+  deleted_at: { type: Date }
+});
+customerSchema.pre("save", async function(next) {
+  if (this.isModified("password")) {
+    this.password = await import_bcryptjs.default.hash(this.password, 12);
+  }
+  next();
+});
+var Customers_default = import_mongoose21.models.Customer || (0, import_mongoose21.model)("Customer", customerSchema, "customers");
+
+// src/customers/models/FiscalProfileType.ts
+var import_mongoose22 = require("mongoose");
+var fiscalProfileSchema = new import_mongoose22.Schema({
+  customer_id: { type: import_mongoose22.Schema.Types.ObjectId, ref: "Customer", required: true },
+  rfc: { type: String, required: true },
+  razon_social: { type: String, required: true },
+  uso_cfdi: { type: String, required: true },
+  regimen_fiscal: { type: String, required: true },
+  cp: { type: String, required: true },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date }
+});
+var FiscalProfileType_default = import_mongoose22.models.FiscalProfile || (0, import_mongoose22.model)("FiscalProfile", fiscalProfileSchema, "fiscal_profiles");
+
+// src/orders/models/Orders.ts
+var import_mongoose23 = require("mongoose");
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["PENDING"] = "pending";
+  OrderStatus2["CONFIRMED"] = "confirmed";
+  OrderStatus2["SHIPPED"] = "shipped";
+  OrderStatus2["CANCELLED"] = "cancelled";
+  OrderStatus2["COMPLETED"] = "completed";
+  return OrderStatus2;
+})(OrderStatus || {});
+var orderItemSchema = new import_mongoose23.Schema(
+  {
+    article_id: { type: import_mongoose23.Schema.Types.ObjectId, ref: "Article", required: true },
+    quantity: { type: Number, required: true },
+    unit_price: { type: Number, required: true },
+    total: { type: Number, required: true }
+  },
+  { _id: false }
+);
+var orderSchema = new import_mongoose23.Schema({
+  customer_id: { type: import_mongoose23.Schema.Types.ObjectId, ref: "Customer", required: true },
+  items: [orderItemSchema],
+  status: {
+    type: String,
+    enum: Object.values(OrderStatus),
+    default: "pending" /* PENDING */
+  },
+  tracking_number: { type: String },
+  total: { type: Number, required: true },
+  notes: { type: String },
+  created_at: { type: Date, default: Date.now },
+  updated_at: { type: Date }
+});
+var Orders_default = import_mongoose23.models.Order || (0, import_mongoose23.model)("Order", orderSchema, "orders");
+
+// src/orders/models/OrderStatusLogs.ts
+var import_mongoose24 = require("mongoose");
+var orderStatusLogSchema = new import_mongoose24.Schema({
+  order_id: {
+    type: import_mongoose24.Schema.Types.ObjectId,
+    ref: "Order",
+    required: true
+  },
+  status: {
+    type: String,
+    enum: Object.values(OrderStatus),
+    required: true
+  },
+  changed_by: {
+    type: import_mongoose24.Schema.Types.ObjectId,
+    ref: "User",
+    required: true
+  },
+  changed_at: {
+    type: Date,
+    default: Date.now
+  },
+  note: {
+    type: String
+  }
+});
+var OrderStatusLogs_default = import_mongoose24.models.OrderStatusLog || (0, import_mongoose24.model)("OrderStatusLog", orderStatusLogSchema, "order_status_logs");
+
+// src/sap/models/SyncLog.ts
+var import_mongoose25 = require("mongoose");
+var SyncLogType = /* @__PURE__ */ ((SyncLogType2) => {
+  SyncLogType2["SAP_QUOTATION"] = "SAP_QUOTATION";
+  SyncLogType2["SAP_SALES_ORDER"] = "SAP_SALES_ORDER";
+  SyncLogType2["PIPEDRIVE"] = "PIPEDRIVE";
+  return SyncLogType2;
+})(SyncLogType || {});
+var SyncLogStatus = /* @__PURE__ */ ((SyncLogStatus2) => {
+  SyncLogStatus2["PENDING"] = "PENDING";
+  SyncLogStatus2["SUCCESS"] = "SUCCESS";
+  SyncLogStatus2["FAILED"] = "FAILED";
+  SyncLogStatus2["RETRYING"] = "RETRYING";
+  return SyncLogStatus2;
+})(SyncLogStatus || {});
+var SyncLogAction = /* @__PURE__ */ ((SyncLogAction2) => {
+  SyncLogAction2["CREATE"] = "CREATE";
+  SyncLogAction2["UPDATE"] = "UPDATE";
+  SyncLogAction2["DELETE"] = "DELETE";
+  return SyncLogAction2;
+})(SyncLogAction || {});
+var syncLogSchema = new import_mongoose25.Schema(
+  {
+    entity_type: {
+      type: String,
+      required: true,
+      index: true
+    },
+    entity_id: {
+      type: import_mongoose25.Schema.Types.ObjectId,
+      required: true,
+      index: true
+    },
+    sync_type: {
+      type: String,
+      enum: Object.values(SyncLogType),
+      required: true,
+      index: true
+    },
+    action: {
+      type: String,
+      enum: Object.values(SyncLogAction),
+      required: true
+    },
+    status: {
+      type: String,
+      enum: Object.values(SyncLogStatus),
+      default: "PENDING" /* PENDING */,
+      index: true
+    },
+    error_message: { type: String },
+    error_code: { type: String },
+    error_details: { type: import_mongoose25.Schema.Types.Mixed },
+    request_payload: { type: import_mongoose25.Schema.Types.Mixed },
+    response_payload: { type: import_mongoose25.Schema.Types.Mixed },
+    retry_count: { type: Number, default: 0 },
+    max_retries: { type: Number, default: 3 },
+    next_retry_at: { type: Date },
+    resolved_at: { type: Date },
+    resolved_by: { type: import_mongoose25.Schema.Types.ObjectId, ref: "User" }
+  },
+  {
+    timestamps: { createdAt: "created_at", updatedAt: "updated_at" }
+  }
+);
+syncLogSchema.index({ entity_type: 1, entity_id: 1, status: 1 });
+syncLogSchema.index({ status: 1, next_retry_at: 1 });
+var SyncLog = import_mongoose25.models.SyncLog || (0, import_mongoose25.model)("SyncLog", syncLogSchema, "sync_logs");
+
+// src/announcements/models/Announcements.ts
+var import_mongoose27 = require("mongoose");
+
+// src/users/models/Users.ts
+var import_mongoose26 = require("mongoose");
+var import_bcryptjs2 = __toESM(require("bcryptjs"), 1);
+var UserRole = /* @__PURE__ */ ((UserRole2) => {
+  UserRole2["ADMIN"] = "admin";
+  UserRole2["SALES"] = "sales";
+  UserRole2["TECHNICIAN"] = "technician";
+  UserRole2["WAREHOUSEMAN"] = "warehouseman";
+  return UserRole2;
+})(UserRole || {});
+var UserStatus = /* @__PURE__ */ ((UserStatus2) => {
+  UserStatus2["ACTIVE"] = "active";
+  UserStatus2["INACTIVE"] = "inactive";
+  UserStatus2["SUSPENDED"] = "suspended";
+  return UserStatus2;
+})(UserStatus || {});
+var usersSchema = new import_mongoose26.Schema({
+  first_name: { type: String, required: true },
+  middle_name: { type: String },
+  last_name: { type: String, required: true },
+  username: { type: String, required: true, unique: true },
+  password: { type: String, required: true, select: false },
+  role: {
+    type: String,
+    enum: Object.values(UserRole),
+    default: "sales" /* SALES */
+  },
+  status: {
+    type: String,
+    enum: Object.values(UserStatus),
+    default: "active" /* ACTIVE */
+  },
+  email: { type: String },
+  mobile: { type: String },
+  pipedrive_id: { type: String },
+  sap_id: { type: String },
+  sap_employee_id: { type: String },
+  created_at: { type: Date, default: Date.now },
+  created_by: { type: import_mongoose26.Schema.Types.Mixed, ref: "User" },
+  updated_at: { type: Date },
+  updated_by: { type: import_mongoose26.Schema.Types.ObjectId, ref: "User" },
+  deleted_at: { type: Date },
+  deleted_by: { type: import_mongoose26.Schema.Types.ObjectId, ref: "User" }
+});
+usersSchema.pre("save", async function(next) {
+  if (this.isModified("password")) {
+    this.password = await import_bcryptjs2.default.hash(this.password, 12);
+  }
+  next();
+});
+var Users_default = import_mongoose26.models.User || (0, import_mongoose26.model)("User", usersSchema, "users");
+
+// src/announcements/models/Announcements.ts
+var announcementSchema = new import_mongoose27.Schema({
+  created_by: {
+    type: import_mongoose27.Schema.Types.ObjectId,
+    ref: "User",
+    required: true
+  },
+  updated_by: {
+    type: import_mongoose27.Schema.Types.ObjectId,
+    ref: "User"
+  },
+  deleted_by: {
+    type: import_mongoose27.Schema.Types.ObjectId,
+    ref: "User"
+  },
+  created_at: {
+    type: Date,
+    default: Date.now
+  },
+  updated_at: Date,
+  deleted_at: Date,
+  title: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  text: {
+    type: String,
+    required: true,
+    trim: true
+  },
+  roles: {
+    type: [String],
+    enum: Object.values(UserRole),
+    required: true,
+    validate: {
+      validator: (roles) => roles.length > 0,
+      message: "At least one user role must be assigned."
+    }
+  }
+});
+var Announcements_default = import_mongoose27.models.Announcement || (0, import_mongoose27.model)("Announcement", announcementSchema, "announcements");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Announcement,
+  Article,
+  ArticleClass,
+  ArticleGroup,
+  ArticlePrice,
+  Client,
+  ClientAddress,
+  ClientContact,
+  ClientPaymentMethod,
+  ClientPaymentTerm,
+  ClientPriceList,
+  ClientSalesEmployee,
+  CreatedMethod,
+  Currency,
+  Customer,
+  FiscalProfile,
+  InventoryStock,
+  Order,
+  OrderStatus,
+  OrderStatusLog,
+  PriceList,
+  Quote,
+  QuoteArticle,
+  QuoteArticleExtra,
+  QuoteContact,
+  QuoteStatus,
+  QuoteTerm,
+  Status,
+  SyncLog,
+  SyncLogAction,
+  SyncLogStatus,
+  SyncLogType,
+  UserRole,
+  UserStatus,
+  Users,
+  Warehouse
+});
+//# sourceMappingURL=index.cjs.map