@experts_hub/shared 1.0.611 → 1.0.614

package/dist/index.mjs

@@ -1127,7 +1127,7 @@ var ClientServiceAgreementUploadDto = class {
 __decorateClass([
   IsOptional15(),
   IsString16()
-], ClientServiceAgreementUploadDto.prototype, "agreementType", 2);
+], ClientServiceAgreementUploadDto.prototype, "serviceAgreementSignedOn", 2);
 
 // src/modules/user/client-profile/dto/client-e-signature.dto.ts
 import { IsNotEmpty as IsNotEmpty34, IsUUID as IsUUID14 } from "class-validator";
@@ -2234,7 +2234,7 @@ import {
   Entity as Entity64,
   Column as Column65,
   OneToMany as OneToMany23,
-  OneToOne as OneToOne12,
+  OneToOne as OneToOne13,
   Index as Index57,
   ManyToOne as ManyToOne59,
   JoinColumn as JoinColumn60
@@ -4178,16 +4178,16 @@ JobRecommendation = __decorateClass([
 ], JobRecommendation);
 
 // src/entities/contract.entity.ts
-import { Entity as Entity30, Column as Column31, Index as Index23, ManyToOne as ManyToOne29, JoinColumn as JoinColumn29, OneToOne as OneToOne9 } from "typeorm";
+import { Entity as Entity30, Column as Column31, Index as Index23, ManyToOne as ManyToOne29, JoinColumn as JoinColumn29, OneToOne as OneToOne10 } from "typeorm";
 
 // src/entities/escrow-wallet.entity.ts
-import { Entity as Entity28, Column as Column29, Index as Index21, JoinColumn as JoinColumn27, OneToOne as OneToOne8, OneToMany as OneToMany11, ManyToOne as ManyToOne27 } from "typeorm";
+import { Entity as Entity29, Column as Column30, Index as Index22, JoinColumn as JoinColumn28, OneToOne as OneToOne9, OneToMany as OneToMany12, ManyToOne as ManyToOne28 } from "typeorm";
 
 // src/entities/escrow-wallet-transaction.entity.ts
-import { Entity as Entity27, Column as Column28, Index as Index20, ManyToOne as ManyToOne26, JoinColumn as JoinColumn26, OneToOne as OneToOne7 } from "typeorm";
+import { Entity as Entity28, Column as Column29, Index as Index21, ManyToOne as ManyToOne27, JoinColumn as JoinColumn27, OneToOne as OneToOne8 } from "typeorm";
 
 // src/entities/invoice.entity.ts
-import { Entity as Entity26, Column as Column27, Index as Index19, JoinColumn as JoinColumn25, ManyToOne as ManyToOne25, OneToOne as OneToOne6 } from "typeorm";
+import { Entity as Entity27, Column as Column28, Index as Index20, JoinColumn as JoinColumn26, ManyToOne as ManyToOne26, OneToOne as OneToOne7 } from "typeorm";
 
 // src/entities/timesheet-line.entity.ts
 import { Entity as Entity24, Column as Column25, Index as Index17, JoinColumn as JoinColumn23, OneToMany as OneToMany10, ManyToOne as ManyToOne23 } from "typeorm";
@@ -4396,7 +4396,110 @@ TimesheetLine = __decorateClass([
 ], TimesheetLine);
 
 // src/entities/hiring.entity.ts
-import { Entity as Entity25, Column as Column26, Index as Index18, ManyToOne as ManyToOne24, JoinColumn as JoinColumn24, OneToOne as OneToOne5 } from "typeorm";
+import { Entity as Entity26, Column as Column27, Index as Index19, ManyToOne as ManyToOne25, JoinColumn as JoinColumn25, OneToOne as OneToOne6 } from "typeorm";
+
+// src/entities/contract-summary.entity.ts
+import { Entity as Entity25, Column as Column26, Index as Index18, ManyToOne as ManyToOne24, JoinColumn as JoinColumn24, OneToMany as OneToMany11, OneToOne as OneToOne5 } from "typeorm";
+var ContractSummaryStatusEnum = /* @__PURE__ */ ((ContractSummaryStatusEnum2) => {
+  ContractSummaryStatusEnum2["PENDING"] = "PENDING";
+  ContractSummaryStatusEnum2["ACTIVE"] = "ACTIVE";
+  ContractSummaryStatusEnum2["COMPLETED"] = "COMPLETED";
+  return ContractSummaryStatusEnum2;
+})(ContractSummaryStatusEnum || {});
+var ContractSummary = class extends BaseEntity {
+};
+__decorateClass([
+  Column26({ name: "job_id", type: "integer", nullable: true }),
+  Index18()
+], ContractSummary.prototype, "jobId", 2);
+__decorateClass([
+  ManyToOne24(() => Job, (job) => job.contracts),
+  JoinColumn24({ name: "job_id" })
+], ContractSummary.prototype, "job", 2);
+__decorateClass([
+  Column26({ name: "client_id", type: "integer", nullable: true }),
+  Index18()
+], ContractSummary.prototype, "clientId", 2);
+__decorateClass([
+  ManyToOne24(() => User, (user) => user.clientContracts),
+  JoinColumn24({ name: "client_id" })
+], ContractSummary.prototype, "client", 2);
+__decorateClass([
+  Column26({ name: "freelancer_id", type: "integer", nullable: true }),
+  Index18()
+], ContractSummary.prototype, "freelancerId", 2);
+__decorateClass([
+  ManyToOne24(() => User, (user) => user.freelancerContracts),
+  JoinColumn24({ name: "freelancer_id" })
+], ContractSummary.prototype, "freelancer", 2);
+__decorateClass([
+  Column26({
+    name: "start_date",
+    type: "timestamp with time zone",
+    nullable: true
+  })
+], ContractSummary.prototype, "startDate", 2);
+__decorateClass([
+  Column26({
+    name: "end_date",
+    type: "timestamp with time zone",
+    nullable: true
+  })
+], ContractSummary.prototype, "endDate", 2);
+__decorateClass([
+  Column26({ name: "duration", type: "integer", nullable: true })
+], ContractSummary.prototype, "duration", 2);
+__decorateClass([
+  Column26({
+    name: "contract_value",
+    type: "decimal",
+    precision: 10,
+    scale: 2,
+    nullable: true
+  })
+], ContractSummary.prototype, "contractValue", 2);
+__decorateClass([
+  Column26({ name: "invoicing_cycle", type: "varchar", nullable: true })
+], ContractSummary.prototype, "invoicingCycle", 2);
+__decorateClass([
+  Column26({ name: "is_msa_signed", type: "boolean", default: false })
+], ContractSummary.prototype, "isMsaSigned", 2);
+__decorateClass([
+  Column26({ name: "is_sow_signed", type: "boolean", default: false })
+], ContractSummary.prototype, "isSowSigned", 2);
+__decorateClass([
+  Column26({ name: "is_escrow_deposited", type: "boolean", default: false })
+], ContractSummary.prototype, "isEscrowDeposited", 2);
+__decorateClass([
+  Column26({
+    name: "escrow_deposite_amount",
+    type: "decimal",
+    precision: 10,
+    scale: 2,
+    nullable: true
+  })
+], ContractSummary.prototype, "escrowDepositeAmount", 2);
+__decorateClass([
+  Column26({
+    name: "status",
+    type: "enum",
+    enum: ContractSummaryStatusEnum,
+    nullable: true
+  })
+], ContractSummary.prototype, "status", 2);
+__decorateClass([
+  OneToMany11(() => Contract, (contract) => contract.contractSummary, {
+    cascade: true
+  })
+], ContractSummary.prototype, "contracts", 2);
+__decorateClass([
+  OneToOne5(() => Hiring, (hiring) => hiring.contractSummary)
+], ContractSummary.prototype, "hirings", 2);
+ContractSummary = __decorateClass([
+  Entity25("contract_summaries")
+], ContractSummary);
+
+// src/entities/hiring.entity.ts
 var HiredFreelancerNatureOfWorkEnum = /* @__PURE__ */ ((HiredFreelancerNatureOfWorkEnum2) => {
   HiredFreelancerNatureOfWorkEnum2["FTE"] = "FTE";
   HiredFreelancerNatureOfWorkEnum2["FREELANCE"] = "FREELANCE";
@@ -4405,39 +4508,50 @@ var HiredFreelancerNatureOfWorkEnum = /* @__PURE__ */ ((HiredFreelancerNatureOfW
 var Hiring = class extends BaseEntity {
 };
 __decorateClass([
-  Column26({ name: "job_id", type: "integer", nullable: true }),
-  Index18()
+  Column27({ name: "job_id", type: "integer", nullable: true }),
+  Index19()
 ], Hiring.prototype, "jobId", 2);
 __decorateClass([
-  ManyToOne24(() => Job, (job) => job.hirings),
-  JoinColumn24({ name: "job_id" })
+  ManyToOne25(() => Job, (job) => job.hirings),
+  JoinColumn25({ name: "job_id" })
 ], Hiring.prototype, "job", 2);
 __decorateClass([
-  Column26({ name: "client_id", type: "integer", nullable: true }),
-  Index18()
+  Column27({ name: "client_id", type: "integer", nullable: true }),
+  Index19()
 ], Hiring.prototype, "clientId", 2);
 __decorateClass([
-  ManyToOne24(() => User, (user) => user.clientHirings),
-  JoinColumn24({ name: "client_id" })
+  ManyToOne25(() => User, (user) => user.clientHirings),
+  JoinColumn25({ name: "client_id" })
 ], Hiring.prototype, "client", 2);
 __decorateClass([
-  Column26({ name: "freelancer_id", type: "integer", nullable: true }),
-  Index18()
+  Column27({ name: "freelancer_id", type: "integer", nullable: true }),
+  Index19()
 ], Hiring.prototype, "freelancerId", 2);
 __decorateClass([
-  ManyToOne24(() => User, (user) => user.freelancerHirings),
-  JoinColumn24({ name: "freelancer_id" })
+  ManyToOne25(() => User, (user) => user.freelancerHirings),
+  JoinColumn25({ name: "freelancer_id" })
 ], Hiring.prototype, "freelancer", 2);
 __decorateClass([
-  Column26({ name: "invoice_id", type: "integer", nullable: true }),
-  Index18()
+  Column27({ name: "invoice_id", type: "integer", nullable: true }),
+  Index19()
 ], Hiring.prototype, "invoiceId", 2);
 __decorateClass([
-  OneToOne5(() => Invoice, (invoice) => invoice.hiring),
-  JoinColumn24({ name: "invoice_id" })
+  OneToOne6(() => Invoice, (invoice) => invoice.hiring),
+  JoinColumn25({ name: "invoice_id" })
 ], Hiring.prototype, "invoice", 2);
 __decorateClass([
-  Column26({
+  Column27({ name: "contract_summary_id", type: "integer", nullable: true }),
+  Index19()
+], Hiring.prototype, "contractSummaryId", 2);
+__decorateClass([
+  OneToOne6(
+    () => ContractSummary,
+    (contractSummary) => contractSummary.hirings
+  ),
+  JoinColumn25({ name: "contract_summary_id" })
+], Hiring.prototype, "contractSummary", 2);
+__decorateClass([
+  Column27({
     name: "freelancer_nature_of_work",
     type: "enum",
     enum: HiredFreelancerNatureOfWorkEnum,
@@ -4445,10 +4559,10 @@ __decorateClass([
   })
 ], Hiring.prototype, "freelancerNatureOfWork", 2);
 __decorateClass([
-  Column26({ name: "is_invoice_genrated", type: "boolean", default: false })
+  Column27({ name: "is_invoice_genrated", type: "boolean", default: false })
 ], Hiring.prototype, "isInvoiceGenrated", 2);
 Hiring = __decorateClass([
-  Entity25("hirings")
+  Entity26("hirings")
 ], Hiring);
 
 // src/entities/invoice.entity.ts
@@ -4476,100 +4590,100 @@ var InvoicePaymentStatusEnum = /* @__PURE__ */ ((InvoicePaymentStatusEnum2) => {
 var Invoice = class extends BaseEntity {
 };
 __decorateClass([
-  Column27({ name: "timesheet_line_id", type: "integer", nullable: true }),
-  Index19()
+  Column28({ name: "timesheet_line_id", type: "integer", nullable: true }),
+  Index20()
 ], Invoice.prototype, "timesheetLineId", 2);
 __decorateClass([
-  ManyToOne25(() => TimesheetLine, (timesheetLine) => timesheetLine.invoice),
-  JoinColumn25({ name: "timesheet_line_id" })
+  ManyToOne26(() => TimesheetLine, (timesheetLine) => timesheetLine.invoice),
+  JoinColumn26({ name: "timesheet_line_id" })
 ], Invoice.prototype, "timesheetLine", 2);
 __decorateClass([
-  Column27({ name: "job_id", type: "integer", nullable: true }),
-  Index19()
+  Column28({ name: "job_id", type: "integer", nullable: true }),
+  Index20()
 ], Invoice.prototype, "jobId", 2);
 __decorateClass([
-  ManyToOne25(() => Job, (job) => job.invoice),
-  JoinColumn25({ name: "job_id" })
+  ManyToOne26(() => Job, (job) => job.invoice),
+  JoinColumn26({ name: "job_id" })
 ], Invoice.prototype, "job", 2);
 __decorateClass([
-  Column27({ name: "client_id", type: "integer", nullable: true }),
-  Index19()
+  Column28({ name: "client_id", type: "integer", nullable: true }),
+  Index20()
 ], Invoice.prototype, "clientId", 2);
 __decorateClass([
-  ManyToOne25(() => User, (user) => user.clientInvoice),
-  JoinColumn25({ name: "client_id" })
+  ManyToOne26(() => User, (user) => user.clientInvoice),
+  JoinColumn26({ name: "client_id" })
 ], Invoice.prototype, "client", 2);
 __decorateClass([
-  Column27({ name: "freelancer_id", type: "integer", nullable: true }),
-  Index19()
+  Column28({ name: "freelancer_id", type: "integer", nullable: true }),
+  Index20()
 ], Invoice.prototype, "freelancerId", 2);
 __decorateClass([
-  ManyToOne25(() => User, (user) => user.freelancerInvoice),
-  JoinColumn25({ name: "freelancer_id" })
+  ManyToOne26(() => User, (user) => user.freelancerInvoice),
+  JoinColumn26({ name: "freelancer_id" })
 ], Invoice.prototype, "freelancer", 2);
 __decorateClass([
-  Column27({ name: "invoice_unique_id", type: "varchar", nullable: true })
+  Column28({ name: "invoice_unique_id", type: "varchar", nullable: true })
 ], Invoice.prototype, "invoiceUniqueId", 2);
 __decorateClass([
-  Column27({
+  Column28({
     name: "issued_at",
     type: "date",
     nullable: true
   })
 ], Invoice.prototype, "issuedAt", 2);
 __decorateClass([
-  Column27({
+  Column28({
     name: "due_at",
     type: "date",
     nullable: true
   })
 ], Invoice.prototype, "dueAt", 2);
 __decorateClass([
-  Column27({
+  Column28({
     name: "billing_cycle_from",
     type: "date",
     nullable: true
   })
 ], Invoice.prototype, "billingCycleFrom", 2);
 __decorateClass([
-  Column27({
+  Column28({
     name: "billing_cycle_to",
     type: "date",
     nullable: true
   })
 ], Invoice.prototype, "billingCycleTo", 2);
 __decorateClass([
-  Column27({ name: "billing_hours", type: "varchar", nullable: true })
+  Column28({ name: "billing_hours", type: "varchar", nullable: true })
 ], Invoice.prototype, "billingHours", 2);
 __decorateClass([
-  Column27({ name: "hourly_rate", type: "varchar", nullable: true })
+  Column28({ name: "hourly_rate", type: "varchar", nullable: true })
 ], Invoice.prototype, "hourlyRate", 2);
 __decorateClass([
-  Column27({ name: "billing_amount", type: "varchar", nullable: true })
+  Column28({ name: "billing_amount", type: "varchar", nullable: true })
 ], Invoice.prototype, "billingAmount", 2);
 __decorateClass([
-  Column27({ name: "invoice_type", type: "enum", enum: InvoiceTypeEnum, nullable: true })
+  Column28({ name: "invoice_type", type: "enum", enum: InvoiceTypeEnum, nullable: true })
 ], Invoice.prototype, "invoiceType", 2);
 __decorateClass([
-  Column27({ name: "status", type: "enum", enum: InvoiceStatusEnum, nullable: true })
+  Column28({ name: "status", type: "enum", enum: InvoiceStatusEnum, nullable: true })
 ], Invoice.prototype, "status", 2);
 __decorateClass([
-  Column27({ name: "payment_status", type: "enum", enum: InvoicePaymentStatusEnum, nullable: true })
+  Column28({ name: "payment_status", type: "enum", enum: InvoicePaymentStatusEnum, nullable: true })
 ], Invoice.prototype, "paymentStatus", 2);
 __decorateClass([
-  Column27({ name: "client_invoice_url", type: "varchar", nullable: true })
+  Column28({ name: "client_invoice_url", type: "varchar", nullable: true })
 ], Invoice.prototype, "clientInvoiceUrl", 2);
 __decorateClass([
-  Column27({ name: "freelancer_invoice_url", type: "varchar", nullable: true })
+  Column28({ name: "freelancer_invoice_url", type: "varchar", nullable: true })
 ], Invoice.prototype, "freelancerInvoiceUrl", 2);
 __decorateClass([
-  OneToOne6(() => EscrowWalletTransaction, (escrowWalletTransaction) => escrowWalletTransaction.invoice)
+  OneToOne7(() => EscrowWalletTransaction, (escrowWalletTransaction) => escrowWalletTransaction.invoice)
 ], Invoice.prototype, "escrowWalletTransaction", 2);
 __decorateClass([
-  OneToOne6(() => Hiring, (hiring) => hiring.invoice)
+  OneToOne7(() => Hiring, (hiring) => hiring.invoice)
 ], Invoice.prototype, "hiring", 2);
 Invoice = __decorateClass([
-  Entity26("invoices")
+  Entity27("invoices")
 ], Invoice);
 
 // src/entities/escrow-wallet-transaction.entity.ts
@@ -4586,189 +4700,91 @@ var EscrowWalletTransactionForEnum = /* @__PURE__ */ ((EscrowWalletTransactionFo
 var EscrowWalletTransaction = class extends BaseEntity {
 };
 __decorateClass([
-  Column28({ name: "escrow_wallet_id", type: "integer", nullable: true }),
-  Index20()
+  Column29({ name: "escrow_wallet_id", type: "integer", nullable: true }),
+  Index21()
 ], EscrowWalletTransaction.prototype, "escrowWalletId", 2);
 __decorateClass([
-  ManyToOne26(() => EscrowWallet, (escrowWallet) => escrowWallet.escrowWalletTransactions),
-  JoinColumn26({ name: "wallet_id" })
+  ManyToOne27(() => EscrowWallet, (escrowWallet) => escrowWallet.escrowWalletTransactions),
+  JoinColumn27({ name: "wallet_id" })
 ], EscrowWalletTransaction.prototype, "escrowWallet", 2);
 __decorateClass([
-  Column28({ name: "invoice_id", type: "integer", nullable: true }),
-  Index20()
+  Column29({ name: "invoice_id", type: "integer", nullable: true }),
+  Index21()
 ], EscrowWalletTransaction.prototype, "invoiceId", 2);
 __decorateClass([
-  OneToOne7(() => Invoice, (invoice) => invoice.escrowWalletTransaction),
-  JoinColumn26({ name: "invoice_id" })
+  OneToOne8(() => Invoice, (invoice) => invoice.escrowWalletTransaction),
+  JoinColumn27({ name: "invoice_id" })
 ], EscrowWalletTransaction.prototype, "invoice", 2);
 __decorateClass([
-  Column28({ name: "amount", type: "bigint", nullable: true })
+  Column29({ name: "amount", type: "bigint", nullable: true })
 ], EscrowWalletTransaction.prototype, "amount", 2);
 __decorateClass([
-  Column28({ name: "escrow_type", type: "enum", enum: EscrowWalletTransactionTypeEnum })
+  Column29({ name: "escrow_type", type: "enum", enum: EscrowWalletTransactionTypeEnum })
 ], EscrowWalletTransaction.prototype, "escrowType", 2);
 __decorateClass([
-  Column28({ name: "description", type: "text", nullable: true })
+  Column29({ name: "description", type: "text", nullable: true })
 ], EscrowWalletTransaction.prototype, "description", 2);
 __decorateClass([
-  Column28({ name: "completed_at", type: "timestamptz", nullable: true })
+  Column29({ name: "completed_at", type: "timestamptz", nullable: true })
 ], EscrowWalletTransaction.prototype, "completedAt", 2);
 __decorateClass([
-  Column28({ name: "escrow_transaction_for", type: "enum", enum: EscrowWalletTransactionForEnum })
+  Column29({ name: "escrow_transaction_for", type: "enum", enum: EscrowWalletTransactionForEnum })
 ], EscrowWalletTransaction.prototype, "escrowTransactionFor", 2);
 __decorateClass([
-  Column28({ name: "meta_data", type: "varchar", nullable: true })
+  Column29({ name: "meta_data", type: "varchar", nullable: true })
 ], EscrowWalletTransaction.prototype, "metaData", 2);
 EscrowWalletTransaction = __decorateClass([
-  Entity27("escrow_wallet_transactions")
+  Entity28("escrow_wallet_transactions")
 ], EscrowWalletTransaction);
 
 // src/entities/escrow-wallet.entity.ts
 var EscrowWallet = class extends BaseEntity {
 };
 __decorateClass([
-  Column29({ name: "job_id", type: "integer", nullable: true }),
-  Index21()
+  Column30({ name: "job_id", type: "integer", nullable: true }),
+  Index22()
 ], EscrowWallet.prototype, "jobId", 2);
 __decorateClass([
-  ManyToOne27(() => Job, (job) => job.escrowWallets),
-  JoinColumn27({ name: "job_id" })
+  ManyToOne28(() => Job, (job) => job.escrowWallets),
+  JoinColumn28({ name: "job_id" })
 ], EscrowWallet.prototype, "job", 2);
 __decorateClass([
-  Column29({ name: "client_id", type: "integer", nullable: true }),
-  Index21()
+  Column30({ name: "client_id", type: "integer", nullable: true }),
+  Index22()
 ], EscrowWallet.prototype, "clientId", 2);
 __decorateClass([
-  ManyToOne27(() => User, (user) => user.clientEscrowWallets),
-  JoinColumn27({ name: "client_id" })
+  ManyToOne28(() => User, (user) => user.clientEscrowWallets),
+  JoinColumn28({ name: "client_id" })
 ], EscrowWallet.prototype, "client", 2);
 __decorateClass([
-  Column29({ name: "freelancer_id", type: "integer", nullable: true }),
-  Index21()
+  Column30({ name: "freelancer_id", type: "integer", nullable: true }),
+  Index22()
 ], EscrowWallet.prototype, "freelancerId", 2);
 __decorateClass([
-  ManyToOne27(() => User, (user) => user.freelancerEscrowWallets),
-  JoinColumn27({ name: "freelancer_id" })
+  ManyToOne28(() => User, (user) => user.freelancerEscrowWallets),
+  JoinColumn28({ name: "freelancer_id" })
 ], EscrowWallet.prototype, "freelancer", 2);
 __decorateClass([
-  Column29({ name: "contract_id", type: "integer", nullable: true }),
-  Index21()
+  Column30({ name: "contract_id", type: "integer", nullable: true }),
+  Index22()
 ], EscrowWallet.prototype, "contractId", 2);
 __decorateClass([
-  OneToOne8(() => Contract, (contract) => contract.escrowWallet),
-  JoinColumn27({ name: "contract_id" })
+  OneToOne9(() => Contract, (contract) => contract.escrowWallet),
+  JoinColumn28({ name: "contract_id" })
 ], EscrowWallet.prototype, "contract", 2);
 __decorateClass([
-  Column29({ name: "wallet_balance", type: "varchar", default: "0" })
+  Column30({ name: "wallet_balance", type: "varchar", default: "0" })
 ], EscrowWallet.prototype, "escrowBalance", 2);
 __decorateClass([
-  Column29({ name: "metadata", type: "jsonb", nullable: true })
+  Column30({ name: "metadata", type: "jsonb", nullable: true })
 ], EscrowWallet.prototype, "metadata", 2);
 __decorateClass([
-  OneToMany11(() => EscrowWalletTransaction, (escrowWalletTransaction) => escrowWalletTransaction.escrowWallet)
+  OneToMany12(() => EscrowWalletTransaction, (escrowWalletTransaction) => escrowWalletTransaction.escrowWallet)
 ], EscrowWallet.prototype, "escrowWalletTransactions", 2);
 EscrowWallet = __decorateClass([
-  Entity28("escrow_wallets")
+  Entity29("escrow_wallets")
 ], EscrowWallet);
 
-// src/entities/contract-summary.entity.ts
-import { Entity as Entity29, Column as Column30, Index as Index22, ManyToOne as ManyToOne28, JoinColumn as JoinColumn28, OneToMany as OneToMany12 } from "typeorm";
-var ContractSummaryStatusEnum = /* @__PURE__ */ ((ContractSummaryStatusEnum2) => {
-  ContractSummaryStatusEnum2["PENDING"] = "PENDING";
-  ContractSummaryStatusEnum2["ACTIVE"] = "ACTIVE";
-  ContractSummaryStatusEnum2["COMPLETED"] = "COMPLETED";
-  return ContractSummaryStatusEnum2;
-})(ContractSummaryStatusEnum || {});
-var ContractSummary = class extends BaseEntity {
-};
-__decorateClass([
-  Column30({ name: "job_id", type: "integer", nullable: true }),
-  Index22()
-], ContractSummary.prototype, "jobId", 2);
-__decorateClass([
-  ManyToOne28(() => Job, (job) => job.contracts),
-  JoinColumn28({ name: "job_id" })
-], ContractSummary.prototype, "job", 2);
-__decorateClass([
-  Column30({ name: "client_id", type: "integer", nullable: true }),
-  Index22()
-], ContractSummary.prototype, "clientId", 2);
-__decorateClass([
-  ManyToOne28(() => User, (user) => user.clientContracts),
-  JoinColumn28({ name: "client_id" })
-], ContractSummary.prototype, "client", 2);
-__decorateClass([
-  Column30({ name: "freelancer_id", type: "integer", nullable: true }),
-  Index22()
-], ContractSummary.prototype, "freelancerId", 2);
-__decorateClass([
-  ManyToOne28(() => User, (user) => user.freelancerContracts),
-  JoinColumn28({ name: "freelancer_id" })
-], ContractSummary.prototype, "freelancer", 2);
-__decorateClass([
-  Column30({
-    name: "start_date",
-    type: "timestamp with time zone",
-    nullable: true
-  })
-], ContractSummary.prototype, "startDate", 2);
-__decorateClass([
-  Column30({
-    name: "end_date",
-    type: "timestamp with time zone",
-    nullable: true
-  })
-], ContractSummary.prototype, "endDate", 2);
-__decorateClass([
-  Column30({ name: "duration", type: "integer", nullable: true })
-], ContractSummary.prototype, "duration", 2);
-__decorateClass([
-  Column30({
-    name: "contract_value",
-    type: "decimal",
-    precision: 10,
-    scale: 2,
-    nullable: true
-  })
-], ContractSummary.prototype, "contractValue", 2);
-__decorateClass([
-  Column30({ name: "invoicing_cycle", type: "varchar", nullable: true })
-], ContractSummary.prototype, "invoicingCycle", 2);
-__decorateClass([
-  Column30({ name: "is_msa_signed", type: "boolean", default: false })
-], ContractSummary.prototype, "isMsaSigned", 2);
-__decorateClass([
-  Column30({ name: "is_sow_signed", type: "boolean", default: false })
-], ContractSummary.prototype, "isSowSigned", 2);
-__decorateClass([
-  Column30({ name: "is_escrow_deposited", type: "boolean", default: false })
-], ContractSummary.prototype, "isEscrowDeposited", 2);
-__decorateClass([
-  Column30({
-    name: "escrow_deposite_amount",
-    type: "decimal",
-    precision: 10,
-    scale: 2,
-    nullable: true
-  })
-], ContractSummary.prototype, "escrowDepositeAmount", 2);
-__decorateClass([
-  Column30({
-    name: "status",
-    type: "enum",
-    enum: ContractSummaryStatusEnum,
-    nullable: true
-  })
-], ContractSummary.prototype, "status", 2);
-__decorateClass([
-  OneToMany12(() => Contract, (contract) => contract.contractSummary, {
-    cascade: true
-  })
-], ContractSummary.prototype, "contracts", 2);
-ContractSummary = __decorateClass([
-  Entity29("contract_summaries")
-], ContractSummary);
-
 // src/entities/contract.entity.ts
 var ContractStatusEnum = /* @__PURE__ */ ((ContractStatusEnum2) => {
   ContractStatusEnum2["GENERATED"] = "GENERATED";
@@ -4928,7 +4944,7 @@ __decorateClass([
   Column31({ name: "meta_data", type: "jsonb", nullable: true })
 ], Contract.prototype, "metaData", 2);
 __decorateClass([
-  OneToOne9(() => EscrowWallet, (escrowWallet) => escrowWallet.contract)
+  OneToOne10(() => EscrowWallet, (escrowWallet) => escrowWallet.contract)
 ], Contract.prototype, "escrowWallet", 2);
 Contract = __decorateClass([
   Entity30("contracts")
@@ -6608,7 +6624,7 @@ StripeTransaction = __decorateClass([
 ], StripeTransaction);
 
 // src/entities/wallet.entity.ts
-import { Entity as Entity62, Column as Column63, Index as Index55, JoinColumn as JoinColumn58, OneToOne as OneToOne11, OneToMany as OneToMany22 } from "typeorm";
+import { Entity as Entity62, Column as Column63, Index as Index55, JoinColumn as JoinColumn58, OneToOne as OneToOne12, OneToMany as OneToMany22 } from "typeorm";
 
 // src/entities/wallet-transaction.entity.ts
 import { Entity as Entity61, Column as Column62, Index as Index54, ManyToOne as ManyToOne57, JoinColumn as JoinColumn57 } from "typeorm";
@@ -6689,7 +6705,7 @@ __decorateClass([
   Index55()
 ], Wallet.prototype, "userId", 2);
 __decorateClass([
-  OneToOne11(() => User, (user) => user.wallet),
+  OneToOne12(() => User, (user) => user.wallet),
   JoinColumn58({ name: "user_id" })
 ], Wallet.prototype, "user", 2);
 __decorateClass([
@@ -6918,7 +6934,7 @@ __decorateClass([
   OneToMany23(() => SenseloafLog, (senseloafLog) => senseloafLog.user)
 ], User.prototype, "senseloafLogs", 2);
 __decorateClass([
-  OneToOne12(() => CompanyProfile, (companyProfile) => companyProfile.user)
+  OneToOne13(() => CompanyProfile, (companyProfile) => companyProfile.user)
 ], User.prototype, "companyProfile", 2);
 __decorateClass([
   OneToMany23(() => CompanySkill, (companySkill) => companySkill.user)
@@ -6936,13 +6952,13 @@ __decorateClass([
   OneToMany23(() => F2FInterview, (F2FInterview2) => F2FInterview2.interviwer)
 ], User.prototype, "clientF2FInterviews", 2);
 __decorateClass([
-  OneToOne12(
+  OneToOne13(
     () => FreelancerProfile,
     (freelancerProfile) => freelancerProfile.user
   )
 ], User.prototype, "freelancerProfile", 2);
 __decorateClass([
-  OneToOne12(() => FreelancerResume, (freelancerResume) => freelancerResume.user)
+  OneToOne13(() => FreelancerResume, (freelancerResume) => freelancerResume.user)
 ], User.prototype, "freelancerResume", 2);
 __decorateClass([
   OneToMany23(
@@ -7005,7 +7021,7 @@ __decorateClass([
   )
 ], User.prototype, "freelancerFramework", 2);
 __decorateClass([
-  OneToOne12(
+  OneToOne13(
     () => FreelancerDeclaration,
     (freelancerDeclaration) => freelancerDeclaration.user
   )
@@ -7093,7 +7109,7 @@ __decorateClass([
   OneToMany23(() => EscrowWallet, (escrowWallet) => escrowWallet.freelancer)
 ], User.prototype, "freelancerEscrowWallets", 2);
 __decorateClass([
-  OneToOne12(() => Signature, (signature) => signature.user)
+  OneToOne13(() => Signature, (signature) => signature.user)
 ], User.prototype, "signatures", 2);
 __decorateClass([
   OneToMany23(() => Timesheet, (timesheet) => timesheet.client)
@@ -7126,7 +7142,7 @@ __decorateClass([
   OneToMany23(() => Dispute, (dispute) => dispute.respondent, { cascade: true })
 ], User.prototype, "respondentDisputes", 2);
 __decorateClass([
-  OneToOne12(() => Wallet, (wallet) => wallet.user)
+  OneToOne13(() => Wallet, (wallet) => wallet.user)
 ], User.prototype, "wallet", 2);
 __decorateClass([
   OneToMany23(() => StripeTransaction, (stripeTransaction) => stripeTransaction.user, { cascade: true })
@@ -9679,7 +9695,7 @@ var RejectF2FInterviewRescheduleRequestDto = class {
 __decorateClass([
   IsOptional58(),
   IsString60()
-], RejectF2FInterviewRescheduleRequestDto.prototype, "reason", 2);
+], RejectF2FInterviewRescheduleRequestDto.prototype, "clientRejectReason", 2);
 
 // src/modules/interview/dto/capture-ai-interview-result-public.dto.ts
 import { IsNotEmpty as IsNotEmpty85, IsString as IsString61, IsOptional as IsOptional59, IsObject as IsObject6 } from "class-validator";
@@ -10673,14 +10689,1113 @@ __decorateClass([
   IsNotEmpty119({ message: "Invoice UUID is required." })
 ], DebitCommissionFteHiringDto.prototype, "invoiceUuid", 2);
 
+// src/modules/discord/discord-alert.interface.ts
+var AlertSeverity = /* @__PURE__ */ ((AlertSeverity2) => {
+  AlertSeverity2["CRITICAL"] = "CRITICAL";
+  AlertSeverity2["ERROR"] = "ERROR";
+  AlertSeverity2["WARNING"] = "WARNING";
+  AlertSeverity2["SECURITY"] = "SECURITY";
+  AlertSeverity2["INFO"] = "INFO";
+  AlertSeverity2["SUCCESS"] = "SUCCESS";
+  return AlertSeverity2;
+})(AlertSeverity || {});
+var AlertCategory = /* @__PURE__ */ ((AlertCategory2) => {
+  AlertCategory2["CRITICAL_ERROR"] = "CRITICAL_ERROR";
+  AlertCategory2["DATABASE"] = "DATABASE";
+  AlertCategory2["PAYMENT"] = "PAYMENT";
+  AlertCategory2["SECURITY"] = "SECURITY";
+  AlertCategory2["PERFORMANCE"] = "PERFORMANCE";
+  AlertCategory2["BUSINESS_EVENT"] = "BUSINESS_EVENT";
+  return AlertCategory2;
+})(AlertCategory || {});
+
+// src/modules/discord/alert-builder.ts
+var AlertBuilder = class {
+  /**
+   * Builds a Discord embed from alert options
+   * 
+   * @param options - Alert configuration
+   * @returns Discord-compatible embed object
+   */
+  static buildEmbed(options) {
+    const fields = [];
+    if (options.metadata?.microservice) {
+      fields.push({
+        name: "\u{1F527} Microservice",
+        value: this.formatValue(options.metadata.microservice),
+        inline: true
+      });
+    }
+    if (options.metadata?.environment) {
+      fields.push({
+        name: "\u{1F30D} Environment",
+        value: this.formatEnvironment(options.metadata.environment),
+        inline: true
+      });
+    }
+    fields.push({
+      name: "\u23F0 Time",
+      value: this.formatTimestamp(/* @__PURE__ */ new Date()),
+      inline: true
+    });
+    if (options.fields) {
+      Object.entries(options.fields).forEach(([key, value]) => {
+        if (value !== null && value !== void 0 && value !== "") {
+          fields.push({
+            name: key,
+            value: this.formatValue(value),
+            inline: this.shouldBeInline(key)
+          });
+        }
+      });
+    }
+    if (options.metadata?.userId) {
+      fields.push({
+        name: "\u{1F464} User ID",
+        value: `\`${options.metadata.userId}\``,
+        inline: true
+      });
+    }
+    if (options.metadata?.correlationId) {
+      fields.push({
+        name: "\u{1F50D} Correlation ID",
+        value: `\`${options.metadata.correlationId}\``,
+        inline: false
+      });
+    }
+    if (options.metadata?.requestPath) {
+      const method = options.metadata.requestMethod || "UNKNOWN";
+      fields.push({
+        name: "\u{1F310} Request",
+        value: `\`${method} ${options.metadata.requestPath}\``,
+        inline: false
+      });
+    }
+    if (options.metadata?.errorStack && (options.severity === "CRITICAL" /* CRITICAL */ || options.severity === "ERROR" /* ERROR */)) {
+      const truncatedStack = this.truncateStack(options.metadata.errorStack);
+      fields.push({
+        name: "\u{1F4CB} Stack Trace",
+        value: `\`\`\`${truncatedStack}\`\`\``,
+        inline: false
+      });
+    }
+    const embed = {
+      title: this.formatTitle(options.severity, options.title),
+      description: this.truncateDescription(options.description),
+      color: this.COLORS[options.severity],
+      fields,
+      footer: {
+        text: this.buildFooter(options)
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return embed;
+  }
+  /**
+   * Formats the embed title with severity emoji
+   */
+  static formatTitle(severity, title) {
+    const emoji = this.SEVERITY_EMOJIS[severity];
+    return `${emoji} ${title}`;
+  }
+  /**
+   * Formats environment with visual emphasis
+   */
+  static formatEnvironment(env) {
+    const formatted = env.toUpperCase();
+    if (env.toLowerCase() === "production") {
+      return `\u{1F6A8} **${formatted}**`;
+    }
+    return `**${formatted}**`;
+  }
+  /**
+   * Formats a timestamp for display
+   */
+  static formatTimestamp(date) {
+    return `<t:${Math.floor(date.getTime() / 1e3)}:F>`;
+  }
+  /**
+   * Formats a field value with appropriate styling
+   */
+  static formatValue(value) {
+    if (typeof value === "boolean") {
+      return value ? "\u2705 Yes" : "\u274C No";
+    }
+    if (typeof value === "number") {
+      return value.toLocaleString();
+    }
+    const strValue = String(value);
+    if (strValue.startsWith("http://") || strValue.startsWith("https://")) {
+      return strValue;
+    }
+    if (this.looksLikeCode(strValue)) {
+      return `\`${strValue}\``;
+    }
+    return strValue;
+  }
+  /**
+   * Determines if a field should be displayed inline
+   * Long values or certain field types should be full-width
+   */
+  static shouldBeInline(fieldName) {
+    const fullWidthFields = [
+      "stack",
+      "trace",
+      "error",
+      "message",
+      "description",
+      "url",
+      "path",
+      "query"
+    ];
+    const lowerFieldName = fieldName.toLowerCase();
+    return !fullWidthFields.some((keyword) => lowerFieldName.includes(keyword));
+  }
+  /**
+   * Checks if a string looks like code/ID that should be formatted
+   */
+  static looksLikeCode(value) {
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+      return true;
+    }
+    if (/^[A-Z0-9_-]{3,20}$/i.test(value) && value.includes("_")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Truncates error stack trace to fit Discord limits
+   * Discord field value limit: 1024 characters
+   */
+  static truncateStack(stack) {
+    const maxLength = 900;
+    if (stack.length <= maxLength) {
+      return stack;
+    }
+    const truncated = stack.substring(0, maxLength);
+    const lastNewline = truncated.lastIndexOf("\n");
+    if (lastNewline > maxLength - 100) {
+      return truncated.substring(0, lastNewline) + "\n... (truncated)";
+    }
+    return truncated + "... (truncated)";
+  }
+  /**
+   * Truncates description to fit Discord limits
+   * Discord embed description limit: 4096 characters
+   */
+  static truncateDescription(description) {
+    const maxLength = 4e3;
+    if (description.length <= maxLength) {
+      return description;
+    }
+    return description.substring(0, maxLength) + "... (truncated)";
+  }
+  /**
+   * Builds the footer text with server information
+   */
+  static buildFooter(options) {
+    const parts = [];
+    if (options.metadata?.hostname) {
+      parts.push(`Server: ${options.metadata.hostname}`);
+    }
+    if (parts.length === 0) {
+      parts.push("ExpertsHub Monitoring System");
+    }
+    return parts.join(" \u2022 ");
+  }
+  /**
+   * Validates an embed structure before sending
+   * Ensures it meets Discord API requirements
+   * 
+   * @param embed - Embed to validate
+   * @returns Validation errors (empty array if valid)
+   */
+  static validateEmbed(embed) {
+    const errors = [];
+    const LIMITS = {
+      TITLE: 256,
+      DESCRIPTION: 4096,
+      FIELDS: 25,
+      FIELD_NAME: 256,
+      FIELD_VALUE: 1024,
+      FOOTER_TEXT: 2048,
+      TOTAL_CHARACTERS: 6e3
+    };
+    if (embed.title && embed.title.length > LIMITS.TITLE) {
+      errors.push(`Title exceeds ${LIMITS.TITLE} characters`);
+    }
+    if (embed.description && embed.description.length > LIMITS.DESCRIPTION) {
+      errors.push(`Description exceeds ${LIMITS.DESCRIPTION} characters`);
+    }
+    if (embed.fields && embed.fields.length > LIMITS.FIELDS) {
+      errors.push(`Too many fields (max ${LIMITS.FIELDS})`);
+    }
+    embed.fields?.forEach((field, index) => {
+      if (field.name.length > LIMITS.FIELD_NAME) {
+        errors.push(`Field ${index} name exceeds ${LIMITS.FIELD_NAME} characters`);
+      }
+      if (field.value.length > LIMITS.FIELD_VALUE) {
+        errors.push(`Field ${index} value exceeds ${LIMITS.FIELD_VALUE} characters`);
+      }
+    });
+    if (embed.footer && embed.footer.text.length > LIMITS.FOOTER_TEXT) {
+      errors.push(`Footer exceeds ${LIMITS.FOOTER_TEXT} characters`);
+    }
+    const totalChars = (embed.title?.length || 0) + (embed.description?.length || 0) + (embed.footer?.text.length || 0) + (embed.fields?.reduce((sum, f) => sum + f.name.length + f.value.length, 0) || 0);
+    if (totalChars > LIMITS.TOTAL_CHARACTERS) {
+      errors.push(`Total characters (${totalChars}) exceed limit of ${LIMITS.TOTAL_CHARACTERS}`);
+    }
+    return errors;
+  }
+};
+/**
+ * Color mapping for different severity levels
+ * Colors are in decimal format (Discord API requirement)
+ * 
+ * Hex to Decimal conversion:
+ * - Red (#FF0000) = 16711680
+ * - Orange (#FF6B00) = 16739072
+ * - Yellow (#FFFF00) = 16776960
+ * - Purple (#9B59B6) = 10181046
+ * - Blue (#3498DB) = 3447003
+ * - Green (#00FF00) = 65280
+ */
+AlertBuilder.COLORS = {
+  ["CRITICAL" /* CRITICAL */]: 16711680,
+  // Red
+  ["ERROR" /* ERROR */]: 16739072,
+  // Orange
+  ["WARNING" /* WARNING */]: 16776960,
+  // Yellow
+  ["SECURITY" /* SECURITY */]: 10181046,
+  // Purple
+  ["INFO" /* INFO */]: 3447003,
+  // Blue
+  ["SUCCESS" /* SUCCESS */]: 65280
+  // Green
+};
+/**
+ * Emoji mapping for severity levels
+ * Makes alerts more visually distinct and easier to scan
+ */
+AlertBuilder.SEVERITY_EMOJIS = {
+  ["CRITICAL" /* CRITICAL */]: "\u{1F534}",
+  ["ERROR" /* ERROR */]: "\u{1F7E0}",
+  ["WARNING" /* WARNING */]: "\u{1F7E1}",
+  ["SECURITY" /* SECURITY */]: "\u{1F7E3}",
+  ["INFO" /* INFO */]: "\u{1F535}",
+  ["SUCCESS" /* SUCCESS */]: "\u{1F7E2}"
+};
+
+// src/modules/discord/rate-limiter.ts
+var RateLimiter = class {
+  /**
+   * Creates a new rate limiter instance
+   * 
+   * @param maxAlertsPerMinute - Maximum alerts allowed per minute per webhook (default: 20)
+   *                              Discord allows 30/min, we use 20 for safety margin
+   */
+  constructor(maxAlertsPerMinute = 20) {
+    this.maxAlertsPerMinute = maxAlertsPerMinute;
+    /**
+     * Stores timestamps of recent alerts per webhook URL
+     * Key: webhook URL
+     * Value: array of timestamps (milliseconds since epoch)
+     */
+    this.alertCounts = /* @__PURE__ */ new Map();
+    /**
+     * Stores timestamps of recent unique alerts for deduplication
+     * Key: alert signature (generated from severity, category, title, microservice)
+     * Value: timestamp when alert was last sent (milliseconds since epoch)
+     */
+    this.recentAlerts = /* @__PURE__ */ new Map();
+    /**
+     * Time window for deduplication (5 minutes in milliseconds)
+     * Same alert within this window will be skipped
+     */
+    this.deduplicationWindow = 5 * 60 * 1e3;
+    // 5 minutes
+    /**
+     * Cleanup interval (10 minutes in milliseconds)
+     * Old entries are cleaned up periodically to prevent memory leaks
+     */
+    this.cleanupInterval = 10 * 60 * 1e3;
+    this.startCleanup();
+  }
+  /**
+   * Checks if an alert can be sent to a specific webhook
+   * Based on rate limiting (alerts per minute)
+   * 
+   * @param webhookUrl - The webhook URL to check
+   * @returns true if alert can be sent, false if rate limit exceeded
+   * 
+   * @example
+   * ```typescript
+   * if (rateLimiter.canSendAlert(webhookUrl)) {
+   *   await sendToDiscord(webhookUrl, alert);
+   * } else {
+   *   console.log('Rate limit exceeded, skipping alert');
+   * }
+   * ```
+   */
+  canSendAlert(webhookUrl) {
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    let timestamps = this.alertCounts.get(webhookUrl) || [];
+    timestamps = timestamps.filter((timestamp) => timestamp > oneMinuteAgo);
+    this.alertCounts.set(webhookUrl, timestamps);
+    return timestamps.length < this.maxAlertsPerMinute;
+  }
+  /**
+   * Records that an alert was sent to a webhook
+   * Used for rate limiting tracking
+   * 
+   * @param webhookUrl - The webhook URL where alert was sent
+   * 
+   * @example
+   * ```typescript
+   * await sendToDiscord(webhookUrl, alert);
+   * rateLimiter.recordAlert(webhookUrl);
+   * ```
+   */
+  recordAlert(webhookUrl) {
+    const now = Date.now();
+    const timestamps = this.alertCounts.get(webhookUrl) || [];
+    timestamps.push(now);
+    this.alertCounts.set(webhookUrl, timestamps);
+  }
+  /**
+   * Checks if an alert is a duplicate
+   * Based on alert signature and deduplication window
+   * 
+   * @param alertKey - Unique key identifying the alert
+   * @returns true if duplicate (should skip), false if unique (should send)
+   * 
+   * @example
+   * ```typescript
+   * const alertKey = rateLimiter.generateAlertKey(options);
+   * if (rateLimiter.isDuplicate(alertKey)) {
+   *   console.log('Duplicate alert, skipping');
+   *   return;
+   * }
+   * ```
+   */
+  isDuplicate(alertKey) {
+    const now = Date.now();
+    const lastSent = this.recentAlerts.get(alertKey);
+    if (lastSent && now - lastSent < this.deduplicationWindow) {
+      return true;
+    }
+    this.recentAlerts.set(alertKey, now);
+    return false;
+  }
+  /**
+   * Generates a unique key for an alert based on its characteristics
+   * Used for deduplication
+   * 
+   * The key includes:
+   * - Severity (CRITICAL, ERROR, etc.)
+   * - Category (DATABASE, PAYMENT, etc.)
+   * - Title (error message or event name)
+   * - Microservice name (to distinguish same error from different services)
+   * 
+   * @param components - Components to build the key from
+   * @returns Unique alert key string
+   * 
+   * @example
+   * ```typescript
+   * const key = rateLimiter.generateAlertKey({
+   *   severity: AlertSeverity.CRITICAL,
+   *   category: AlertCategory.DATABASE,
+   *   title: 'Connection failed',
+   *   microservice: 'user-microservice'
+   * });
+   * // Returns: "CRITICAL:DATABASE:Connection failed:user-microservice"
+   * ```
+   */
+  generateAlertKey(components) {
+    const parts = [
+      components.severity,
+      components.category,
+      components.title,
+      components.microservice || "unknown"
+    ];
+    return parts.join(":");
+  }
+  /**
+   * Gets statistics about current rate limiter state
+   * Useful for monitoring and debugging
+   * 
+   * @returns Statistics object
+   */
+  getStats() {
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    const webhookStats = Array.from(this.alertCounts.entries()).map(
+      ([webhookUrl, timestamps]) => {
+        const recentCount = timestamps.filter((t) => t > oneMinuteAgo).length;
+        return {
+          webhook: this.maskWebhookUrl(webhookUrl),
+          alertsInLastMinute: recentCount,
+          remainingCapacity: this.maxAlertsPerMinute - recentCount
+        };
+      }
+    );
+    return {
+      totalWebhooks: this.alertCounts.size,
+      totalUniqueAlerts: this.recentAlerts.size,
+      webhookStats
+    };
+  }
+  /**
+   * Masks webhook URL for safe logging
+   * Hides the token part for security
+   * 
+   * @param url - Full webhook URL
+   * @returns Masked URL
+   * 
+   * @example
+   * Input:  "https://discord.com/api/webhooks/123456/abcdef123456"
+   * Output: "https://discord.com/api/webhooks/123456/***"
+   */
+  maskWebhookUrl(url) {
+    try {
+      const parts = url.split("/");
+      if (parts.length >= 2) {
+        parts[parts.length - 1] = "***";
+      }
+      return parts.join("/");
+    } catch {
+      return "***";
+    }
+  }
+  /**
+   * Clears all rate limiting and deduplication data
+   * Useful for testing or manual resets
+   */
+  clear() {
+    this.alertCounts.clear();
+    this.recentAlerts.clear();
+  }
+  /**
+   * Starts periodic cleanup to prevent memory leaks
+   * Removes old entries from both maps
+   */
+  startCleanup() {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, this.cleanupInterval);
+    if (this.cleanupTimer.unref) {
+      this.cleanupTimer.unref();
+    }
+  }
+  /**
+   * Performs cleanup of old entries
+   * Removes timestamps older than needed for tracking
+   */
+  cleanup() {
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    const deduplicationCutoff = now - this.deduplicationWindow;
+    for (const [webhookUrl, timestamps] of this.alertCounts.entries()) {
+      const filtered = timestamps.filter((t) => t > oneMinuteAgo);
+      if (filtered.length === 0) {
+        this.alertCounts.delete(webhookUrl);
+      } else {
+        this.alertCounts.set(webhookUrl, filtered);
+      }
+    }
+    for (const [alertKey, timestamp] of this.recentAlerts.entries()) {
+      if (timestamp < deduplicationCutoff) {
+        this.recentAlerts.delete(alertKey);
+      }
+    }
+  }
+  /**
+   * Stops the cleanup timer
+   * Should be called when the rate limiter is no longer needed
+   */
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+    this.clear();
+  }
+  /**
+   * Gets the current deduplication window in milliseconds
+   */
+  getDeduplicationWindow() {
+    return this.deduplicationWindow;
+  }
+  /**
+   * Gets the maximum alerts per minute setting
+   */
+  getMaxAlertsPerMinute() {
+    return this.maxAlertsPerMinute;
+  }
+  /**
+   * Checks if a specific webhook is currently rate limited
+   * 
+   * @param webhookUrl - Webhook URL to check
+   * @returns true if rate limited, false otherwise
+   */
+  isRateLimited(webhookUrl) {
+    return !this.canSendAlert(webhookUrl);
+  }
+  /**
+   * Gets remaining capacity for a webhook in the current minute
+   * 
+   * @param webhookUrl - Webhook URL to check
+   * @returns Number of alerts that can still be sent this minute
+   */
+  getRemainingCapacity(webhookUrl) {
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    const timestamps = this.alertCounts.get(webhookUrl) || [];
+    const recentCount = timestamps.filter((t) => t > oneMinuteAgo).length;
+    return Math.max(0, this.maxAlertsPerMinute - recentCount);
+  }
+};
+
+// src/modules/discord/discord-alert.service.ts
+var DiscordAlertService = class {
+  /**
+   * Creates a new Discord alert service instance
+   * 
+   * @param config - Configuration for Discord webhooks
+   * 
+   * @example
+   * ```typescript
+   * const discordService = new DiscordAlertService({
+   *   errorWebhookUrl: process.env.DISCORD_ERROR_WEBHOOK_URL,
+   *   microserviceName: 'user-microservice',
+   *   environment: process.env.NODE_ENV,
+   *   enabled: true,
+   *   rateLimitPerMinute: 20,
+   * });
+   * ```
+   */
+  constructor(config11) {
+    this.alertsSent = 0;
+    this.alertsFailed = 0;
+    this.config = {
+      errorWebhookUrl: config11.errorWebhookUrl || "",
+      securityWebhookUrl: config11.securityWebhookUrl || "",
+      businessWebhookUrl: config11.businessWebhookUrl || "",
+      performanceWebhookUrl: config11.performanceWebhookUrl || "",
+      enabled: config11.enabled !== void 0 ? config11.enabled : true,
+      rateLimitPerMinute: config11.rateLimitPerMinute || 20,
+      environment: config11.environment || "development",
+      microserviceName: config11.microserviceName || "unknown"
+    };
+    this.rateLimiter = new RateLimiter(this.config.rateLimitPerMinute);
+  }
+  /**
+   * Sends an alert to Discord
+   * 
+   * This is the main method for sending alerts. It handles:
+   * - Metadata enrichment (adds microservice, environment, hostname)
+   * - Deduplication (skips if same alert sent recently)
+   * - Rate limiting (respects Discord webhook limits)
+   * - Error handling (fails gracefully without crashing)
+   * 
+   * @param options - Alert configuration
+   * @returns Promise that resolves when alert is sent (or skipped)
+   * 
+   * @example
+   * ```typescript
+   * await discordService.sendAlert({
+   *   severity: AlertSeverity.CRITICAL,
+   *   category: AlertCategory.DATABASE,
+   *   title: 'Database Connection Failed',
+   *   description: 'Unable to connect to PostgreSQL',
+   *   fields: {
+   *     'Host': 'localhost:5432',
+   *     'Error Code': 'ECONNREFUSED',
+   *   },
+   * });
+   * ```
+   */
+  async sendAlert(options) {
+    try {
+      if (!this.config.enabled) {
+        this.log("Discord alerts disabled, skipping");
+        return;
+      }
+      options.metadata = {
+        ...options.metadata,
+        microservice: options.metadata?.microservice || this.config.microserviceName,
+        environment: options.metadata?.environment || this.config.environment,
+        hostname: options.metadata?.hostname || this.getHostname()
+      };
+      const alertKey = this.rateLimiter.generateAlertKey({
+        severity: options.severity,
+        category: options.category,
+        title: options.title,
+        microservice: options.metadata.microservice
+      });
+      if (this.rateLimiter.isDuplicate(alertKey)) {
+        this.log(`Skipping duplicate alert: ${alertKey}`);
+        return;
+      }
+      const webhookUrl = this.getWebhookUrl(options.category);
+      if (!webhookUrl) {
+        this.log(`No webhook URL configured for category: ${options.category}`);
+        return;
+      }
+      if (!this.rateLimiter.canSendAlert(webhookUrl)) {
+        this.log(`Rate limit exceeded for category: ${options.category}`);
+        this.alertsFailed++;
+        return;
+      }
+      const embed = AlertBuilder.buildEmbed(options);
+      const validationErrors = AlertBuilder.validateEmbed(embed);
+      if (validationErrors.length > 0) {
+        this.log(`Embed validation failed: ${validationErrors.join(", ")}`);
+        this.alertsFailed++;
+        return;
+      }
+      const payload = {
+        embeds: [embed],
+        username: `${this.config.microserviceName} Monitor`
+      };
+      await this.sendToWebhook(webhookUrl, payload);
+      this.rateLimiter.recordAlert(webhookUrl);
+      this.alertsSent++;
+      this.log(`Alert sent successfully: ${options.title}`);
+    } catch (error) {
+      this.logError("Failed to send Discord alert", error);
+      this.alertsFailed++;
+    }
+  }
+  /**
+   * Helper method: Send critical error alert
+   * 
+   * @param error - Error object
+   * @param context - Additional context information
+   * 
+   * @example
+   * ```typescript
+   * try {
+   *   await someOperation();
+   * } catch (error) {
+   *   await discordService.sendCriticalError(error, {
+   *     operation: 'someOperation',
+   *     userId: '12345',
+   *   });
+   * }
+   * ```
+   */
+  async sendCriticalError(error, context) {
+    await this.sendAlert({
+      severity: "CRITICAL" /* CRITICAL */,
+      category: "CRITICAL_ERROR" /* CRITICAL_ERROR */,
+      title: "Critical Error Occurred",
+      description: error.message,
+      fields: context,
+      metadata: {
+        errorStack: error.stack
+      }
+    });
+  }
+  /**
+   * Helper method: Send database error alert
+   * 
+   * @param message - Error message
+   * @param context - Additional context
+   */
+  async sendDatabaseError(message, context) {
+    await this.sendAlert({
+      severity: "CRITICAL" /* CRITICAL */,
+      category: "DATABASE" /* DATABASE */,
+      title: "\u{1F5C4}\uFE0F Database Error",
+      description: message,
+      fields: context
+    });
+  }
+  /**
+   * Helper method: Send security alert
+   * 
+   * @param title - Alert title
+   * @param description - Alert description
+   * @param context - Additional context
+   */
+  async sendSecurityAlert(title, description, context) {
+    await this.sendAlert({
+      severity: "SECURITY" /* SECURITY */,
+      category: "SECURITY" /* SECURITY */,
+      title,
+      description,
+      fields: context
+    });
+  }
+  /**
+   * Helper method: Send payment error alert
+   * 
+   * @param message - Error message
+   * @param context - Payment context
+   */
+  async sendPaymentError(message, context) {
+    await this.sendAlert({
+      severity: "CRITICAL" /* CRITICAL */,
+      category: "PAYMENT" /* PAYMENT */,
+      title: "\u{1F4B3} Payment Processing Error",
+      description: message,
+      fields: context
+    });
+  }
+  /**
+   * Helper method: Send business event alert
+   * 
+   * @param title - Event title
+   * @param description - Event description
+   * @param context - Event context
+   */
+  async sendBusinessEvent(title, description, context) {
+    await this.sendAlert({
+      severity: "INFO" /* INFO */,
+      category: "BUSINESS_EVENT" /* BUSINESS_EVENT */,
+      title,
+      description,
+      fields: context
+    });
+  }
+  /**
+   * Helper method: Send performance warning
+   * 
+   * @param title - Warning title
+   * @param description - Warning description
+   * @param metrics - Performance metrics
+   */
+  async sendPerformanceWarning(title, description, metrics) {
+    await this.sendAlert({
+      severity: "WARNING" /* WARNING */,
+      category: "PERFORMANCE" /* PERFORMANCE */,
+      title,
+      description,
+      fields: metrics
+    });
+  }
+  /**
+   * Gets the appropriate webhook URL for an alert category
+   * 
+   * @param category - Alert category
+   * @returns Webhook URL or undefined if not configured
+   */
+  getWebhookUrl(category) {
+    switch (category) {
+      case "CRITICAL_ERROR" /* CRITICAL_ERROR */:
+      case "DATABASE" /* DATABASE */:
+        return this.config.errorWebhookUrl || void 0;
+      case "SECURITY" /* SECURITY */:
+        return this.config.securityWebhookUrl || this.config.errorWebhookUrl || void 0;
+      case "BUSINESS_EVENT" /* BUSINESS_EVENT */:
+      case "PAYMENT" /* PAYMENT */:
+        return this.config.businessWebhookUrl || this.config.errorWebhookUrl || void 0;
+      case "PERFORMANCE" /* PERFORMANCE */:
+        return this.config.performanceWebhookUrl || this.config.errorWebhookUrl || void 0;
+      default:
+        return this.config.errorWebhookUrl || void 0;
+    }
+  }
+  /**
+   * Sends payload to Discord webhook
+   * 
+   * @param webhookUrl - Discord webhook URL
+   * @param payload - Webhook payload
+   */
+  async sendToWebhook(webhookUrl, payload) {
+    const response = await this.httpPost(webhookUrl, payload);
+    if (!response.ok) {
+      throw new Error(
+        `Discord webhook failed: ${response.status} ${response.statusText}`
+      );
+    }
+  }
+  /**
+   * Makes HTTP POST request to webhook
+   * Uses native fetch if available, falls back to simple implementation
+   * 
+   * @param url - Webhook URL
+   * @param data - Payload data
+   * @returns HTTP response
+   */
+  async httpPost(url, data) {
+    try {
+      if (typeof fetch !== "undefined") {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(data)
+        });
+        return {
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText
+        };
+      }
+      throw new Error("fetch not available - please use Node.js 18+ or provide HTTP client");
+    } catch (error) {
+      throw new Error(`HTTP request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Gets hostname for alert metadata
+   */
+  getHostname() {
+    try {
+      return process.env.HOSTNAME || process.env.HOST || "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Simple logging (doesn't use logger to avoid circular dependencies)
+   */
+  log(message) {
+    if (this.config.environment === "development") {
+      console.log(`[DiscordAlertService] ${message}`);
+    }
+  }
+  /**
+   * Error logging
+   */
+  logError(message, error) {
+    console.error(
+      `[DiscordAlertService] ${message}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  /**
+   * Gets service statistics
+   * 
+   * @returns Statistics object
+   */
+  getStats() {
+    const total = this.alertsSent + this.alertsFailed;
+    const successRate = total > 0 ? this.alertsSent / total * 100 : 0;
+    return {
+      alertsSent: this.alertsSent,
+      alertsFailed: this.alertsFailed,
+      successRate: Math.round(successRate * 100) / 100,
+      rateLimiterStats: this.rateLimiter.getStats()
+    };
+  }
+  /**
+   * Resets statistics
+   */
+  resetStats() {
+    this.alertsSent = 0;
+    this.alertsFailed = 0;
+  }
+  /**
+   * Checks if service is properly configured
+   * 
+   * @returns true if at least one webhook URL is configured
+   */
+  isConfigured() {
+    return !!(this.config.errorWebhookUrl || this.config.securityWebhookUrl || this.config.businessWebhookUrl || this.config.performanceWebhookUrl);
+  }
+  /**
+   * Gets current configuration (with masked webhook URLs for security)
+   */
+  getConfig() {
+    return {
+      enabled: this.config.enabled,
+      rateLimitPerMinute: this.config.rateLimitPerMinute,
+      environment: this.config.environment,
+      microserviceName: this.config.microserviceName,
+      webhooksConfigured: {
+        error: !!this.config.errorWebhookUrl,
+        security: !!this.config.securityWebhookUrl,
+        business: !!this.config.businessWebhookUrl,
+        performance: !!this.config.performanceWebhookUrl
+      }
+    };
+  }
+  /**
+   * Cleanup method - call when service is no longer needed
+   */
+  destroy() {
+    this.rateLimiter.destroy();
+  }
+};
+
+// src/modules/discord/winston-discord.transport.ts
+import Transport from "winston-transport";
+var DiscordTransport = class extends Transport {
+  /**
+   * Creates a new Winston Discord transport
+   * 
+   * @param options - Transport configuration
+   */
+  constructor(options) {
+    super({
+      level: options.level || "error"
+    });
+    this.logsSent = 0;
+    this.transportOptions = {
+      level: options.level || "error",
+      microserviceName: options.microserviceName,
+      environment: options.environment,
+      enabled: options.enabled !== void 0 ? options.enabled : true,
+      category: options.category || "CRITICAL_ERROR" /* CRITICAL_ERROR */,
+      severity: options.severity || "CRITICAL" /* CRITICAL */
+    };
+    this.discordService = new DiscordAlertService({
+      errorWebhookUrl: options.webhookUrl,
+      microserviceName: this.transportOptions.microserviceName,
+      environment: this.transportOptions.environment,
+      enabled: this.transportOptions.enabled
+    });
+  }
+  /**
+   * Log method called by Winston for each log entry
+   * Required by winston-transport.Transport
+   * 
+   * @param info - Winston log info object
+   * @param callback - Callback to call when done
+   */
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit("logged", info);
+    });
+    if (!this.transportOptions.enabled || !this.shouldLog(info.level)) {
+      callback();
+      return;
+    }
+    this.sendLogToDiscord(info).catch((error) => {
+      console.error(
+        `[DiscordTransport] Failed to send log to Discord:`,
+        error instanceof Error ? error.message : String(error)
+      );
+    }).finally(() => {
+      callback();
+    });
+  }
+  /**
+   * Determines if a log level should be sent to Discord
+   * 
+   * @param level - Log level from Winston
+   * @returns true if should be sent to Discord
+   */
+  shouldLog(level) {
+    const levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      http: 3,
+      verbose: 4,
+      debug: 5,
+      silly: 6
+    };
+    const targetLevel = levels[this.transportOptions.level] || 0;
+    const currentLevel = levels[level] || 999;
+    return currentLevel <= targetLevel;
+  }
+  /**
+   * Sends log info to Discord as an alert
+   * 
+   * @param info - Winston log info
+   */
+  async sendLogToDiscord(info) {
+    try {
+      const fields = {};
+      if (info.context) {
+        fields["Context"] = info.context;
+      }
+      const excludeFields = [
+        "level",
+        "message",
+        "timestamp",
+        "stack",
+        "correlationId",
+        "context",
+        "error"
+      ];
+      Object.entries(info).forEach(([key, value]) => {
+        if (!excludeFields.includes(key) && typeof value !== "function" && typeof value !== "object") {
+          fields[key] = value;
+        }
+      });
+      const severity = this.mapLogLevelToSeverity(info.level);
+      await this.discordService.sendAlert({
+        severity,
+        category: this.transportOptions.category,
+        title: this.buildTitle(info),
+        description: info.message,
+        fields: Object.keys(fields).length > 0 ? fields : void 0,
+        metadata: {
+          correlationId: info.correlationId,
+          errorStack: info.stack || info.error
+        }
+      });
+      this.logsSent++;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Maps Winston log level to Discord alert severity
+   * 
+   * @param level - Winston log level
+   * @returns Alert severity
+   */
+  mapLogLevelToSeverity(level) {
+    switch (level.toLowerCase()) {
+      case "error":
+        return "CRITICAL" /* CRITICAL */;
+      case "warn":
+        return "WARNING" /* WARNING */;
+      case "info":
+        return "INFO" /* INFO */;
+      default:
+        return "ERROR" /* ERROR */;
+    }
+  }
+  /**
+   * Builds alert title from log info
+   * 
+   * @param info - Winston log info
+   * @returns Alert title
+   */
+  buildTitle(info) {
+    if (info.context) {
+      return `${info.context} Error`;
+    }
+    return `Application ${info.level.toUpperCase()}`;
+  }
+  /**
+   * Gets transport statistics
+   */
+  getStats() {
+    return {
+      logsSent: this.logsSent,
+      discordStats: this.discordService.getStats()
+    };
+  }
+  /**
+   * Cleanup method
+   */
+  close() {
+    this.discordService.destroy();
+  }
+};
+function createDiscordTransport(options) {
+  return new DiscordTransport(options);
+}
+
 // src/adapters/tcp/user.tcp.adapter.ts
 import { config } from "dotenv";
-import { Transport } from "@nestjs/microservices";
+import { Transport as Transport2 } from "@nestjs/microservices";
 config();
 var UserTCPAdapter = () => {
   return {
     name: "USER_MICROSERVICE",
-    transport: Transport.TCP,
+    transport: Transport2.TCP,
     options: {
       host: process.env.USER_MICROSERVICE_TCP_HOST || "localhost",
       port: parseInt(process.env.USER_MICROSERVICE_TCP_PORT || "4001", 10)
@@ -10690,12 +11805,12 @@ var UserTCPAdapter = () => {
 
 // src/adapters/tcp/job.tcp.adapter.ts
 import { config as config2 } from "dotenv";
-import { Transport as Transport2 } from "@nestjs/microservices";
+import { Transport as Transport3 } from "@nestjs/microservices";
 config2();
 var JobTCPAdapter = () => {
   return {
     name: "JOB_MICROSERVICE",
-    transport: Transport2.TCP,
+    transport: Transport3.TCP,
     options: {
       host: process.env.JOB_MICROSERVICE_TCP_HOST || "localhost",
       port: parseInt(process.env.JOB_MICROSERVICE_TCP_PORT || "4002", 10)
@@ -10705,12 +11820,12 @@ var JobTCPAdapter = () => {
 
 // src/adapters/tcp/contract.tcp.adapter.ts
 import { config as config3 } from "dotenv";
-import { Transport as Transport3 } from "@nestjs/microservices";
+import { Transport as Transport4 } from "@nestjs/microservices";
 config3();
 var ContractTCPAdapter = () => {
   return {
     name: "CONTRACT_MICROSERVICE",
-    transport: Transport3.TCP,
+    transport: Transport4.TCP,
     options: {
       host: process.env.CONTRACT_MICROSERVICE_TCP_HOST || "localhost",
       port: parseInt(process.env.CONTRACT_MICROSERVICE_TCP_PORT || "4004", 10)
@@ -10720,12 +11835,12 @@ var ContractTCPAdapter = () => {
 
 // src/adapters/tcp/notification.tcp.adapter.ts
 import { config as config4 } from "dotenv";
-import { Transport as Transport4 } from "@nestjs/microservices";
+import { Transport as Transport5 } from "@nestjs/microservices";
 config4();
 var NotificationTCPAdapter = () => {
   return {
     name: "NOTIFICATION_MICROSERVICE",
-    transport: Transport4.TCP,
+    transport: Transport5.TCP,
     options: {
       host: process.env.NOTIFICATION_MICROSERVICE_TCP_HOST || "localhost",
       port: parseInt(process.env.NOTIFICATION_MICROSERVICE_TCP_PORT || "4003", 10)
@@ -10735,12 +11850,12 @@ var NotificationTCPAdapter = () => {
 
 // src/adapters/tcp/chat.tcp.adapter.ts
 import { config as config5 } from "dotenv";
-import { Transport as Transport5 } from "@nestjs/microservices";
+import { Transport as Transport6 } from "@nestjs/microservices";
 config5();
 var ChatTCPAdapter = () => {
   return {
     name: "CHAT_MICROSERVICE",
-    transport: Transport5.TCP,
+    transport: Transport6.TCP,
     options: {
       host: process.env.CHAT_MICROSERVICE_TCP_HOST || "localhost",
       port: parseInt(process.env.CHAT_MICROSERVICE_TCP_PORT || "4005", 10)
@@ -10750,7 +11865,7 @@ var ChatTCPAdapter = () => {
 
 // src/adapters/rmq/user.rmq.adapter.ts
 import { config as config6 } from "dotenv";
-import { Transport as Transport6 } from "@nestjs/microservices";
+import { Transport as Transport7 } from "@nestjs/microservices";
 config6();
 var UserRMQAdapter = (mode = "microservice") => {
   const urls = process.env.USER_MICROSERVICE_RMQ_URL?.split(",") || [
@@ -10770,7 +11885,7 @@ var UserRMQAdapter = (mode = "microservice") => {
   );
   const config11 = {
     name: "USER_MICROSERVICE",
-    transport: Transport6.RMQ,
+    transport: Transport7.RMQ,
     options: {
       urls,
       queue,
@@ -10807,7 +11922,7 @@ var UserRMQAdapter = (mode = "microservice") => {
 
 // src/adapters/rmq/job.rmq.adapter.ts
 import { config as config7 } from "dotenv";
-import { Transport as Transport7 } from "@nestjs/microservices";
+import { Transport as Transport8 } from "@nestjs/microservices";
 config7();
 var JobRMQAdapter = (mode = "microservice") => {
   const urls = process.env.JOB_MICROSERVICE_RMQ_URL?.split(",") || [
@@ -10827,7 +11942,7 @@ var JobRMQAdapter = (mode = "microservice") => {
   );
   const config11 = {
     name: "JOB_MICROSERVICE",
-    transport: Transport7.RMQ,
+    transport: Transport8.RMQ,
     options: {
       urls,
       queue,
@@ -10864,7 +11979,7 @@ var JobRMQAdapter = (mode = "microservice") => {
 
 // src/adapters/rmq/contract.rmq.adapter.ts
 import { config as config8 } from "dotenv";
-import { Transport as Transport8 } from "@nestjs/microservices";
+import { Transport as Transport9 } from "@nestjs/microservices";
 config8();
 var ContractRMQAdapter = (mode = "microservice") => {
   const urls = process.env.CONTRACT_MICROSERVICE_RMQ_URL?.split(",") || [
@@ -10884,7 +11999,7 @@ var ContractRMQAdapter = (mode = "microservice") => {
   );
   const config11 = {
     name: "CONTRACT_MICROSERVICE",
-    transport: Transport8.RMQ,
+    transport: Transport9.RMQ,
     options: {
       urls,
       queue,
@@ -10921,7 +12036,7 @@ var ContractRMQAdapter = (mode = "microservice") => {
 
 // src/adapters/rmq/notification.rmq.adapter.ts
 import { config as config9 } from "dotenv";
-import { Transport as Transport9 } from "@nestjs/microservices";
+import { Transport as Transport10 } from "@nestjs/microservices";
 config9();
 var NotificationRMQAdapter = (mode = "microservice") => {
   const urls = process.env.NOTIFICATION_MICROSERVICE_RMQ_URL?.split(",") || [
@@ -10941,7 +12056,7 @@ var NotificationRMQAdapter = (mode = "microservice") => {
   );
   const config11 = {
     name: "NOTIFICATION_MICROSERVICE",
-    transport: Transport9.RMQ,
+    transport: Transport10.RMQ,
     options: {
       urls,
       queue,
@@ -10978,7 +12093,7 @@ var NotificationRMQAdapter = (mode = "microservice") => {
 
 // src/adapters/rmq/chat.rmq.adapter.ts
 import { config as config10 } from "dotenv";
-import { Transport as Transport10 } from "@nestjs/microservices";
+import { Transport as Transport11 } from "@nestjs/microservices";
 config10();
 var ChatRMQAdapter = (mode = "microservice") => {
   const urls = process.env.CHAT_MICROSERVICE_RMQ_URL?.split(",") || [
@@ -10998,7 +12113,7 @@ var ChatRMQAdapter = (mode = "microservice") => {
   );
   const config11 = {
     name: "CHAT_MICROSERVICE",
-    transport: Transport10.RMQ,
+    transport: Transport11.RMQ,
     options: {
       urls,
       queue,
@@ -11709,6 +12824,9 @@ export {
   AiInterviewStatusEnum,
   AiInterviewTemplateGenerationDto,
   AiQuestionItemDto,
+  AlertBuilder,
+  AlertCategory,
+  AlertSeverity,
   AnswerTypeEnum,
   ApplicationStatusEnum,
   ApproveTimesheetsDto,
@@ -11807,6 +12925,8 @@ export {
   CustomQuestionItemDto,
   DISPUTE_PATTERN,
   DebitCommissionFteHiringDto,
+  DiscordAlertService,
+  DiscordTransport,
   Dispute,
   DisputeStatusEnum,
   DocumentType,
@@ -11963,6 +13083,7 @@ export {
   QuestionForEnum,
   RATING_PATTERN,
   RESUME_PARSER_PATTERN,
+  RateLimiter,
   Rating,
   RatingTypeEnum,
   RecommendationWeightageConfig,
@@ -12082,6 +13203,7 @@ export {
   WalletTransactionTypeEnum,
   ZOOM_PATTERN,
   ZoomMeetingLog,
+  createDiscordTransport,
   typeOfExperienceDtoEnumV2,
   typeOfExperienceEnum
 };