c2-desafiox 1.0.136 → 1.0.143

package/dist/models/ChatMessage.d.ts

@@ -84,8 +84,8 @@ export declare const ChatMessageSchema: Schema<any, import("mongoose").Model<any
         seenBy?: Types.ObjectId | null | undefined;
         seenDateTime?: NativeDate | null | undefined;
     }>;
-    content?: string | null | undefined;
     category?: string | null | undefined;
+    content?: string | null | undefined;
 }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
     status: string;
     chat: Types.ObjectId;
@@ -133,8 +133,8 @@ export declare const ChatMessageSchema: Schema<any, import("mongoose").Model<any
         seenBy?: Types.ObjectId | null | undefined;
         seenDateTime?: NativeDate | null | undefined;
     }>;
-    content?: string | null | undefined;
     category?: string | null | undefined;
+    content?: string | null | undefined;
 }>, {}> & import("mongoose").FlatRecord<{} & {
     status: string;
     chat: Types.ObjectId;
@@ -182,8 +182,8 @@ export declare const ChatMessageSchema: Schema<any, import("mongoose").Model<any
         seenBy?: Types.ObjectId | null | undefined;
         seenDateTime?: NativeDate | null | undefined;
     }>;
-    content?: string | null | undefined;
     category?: string | null | undefined;
+    content?: string | null | undefined;
 }> & {
     _id: Types.ObjectId;
 } & {

package/dist/models/EventComunication.d.ts

@@ -51,6 +51,7 @@ export declare const EventComunicationSchema: Schema<any, import("mongoose").Mod
         isValid?: {} | null | undefined;
     };
     status: string;
+    content: any;
     comunication: {
         prototype?: Types.ObjectId | null | undefined;
         cacheHexString?: unknown;
@@ -61,7 +62,6 @@ export declare const EventComunicationSchema: Schema<any, import("mongoose").Mod
         isValid?: {} | null | undefined;
     };
     statusDelivery: string;
-    content: any;
     message?: string | null | undefined;
 }, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{} & {
     type: string;
@@ -75,6 +75,7 @@ export declare const EventComunicationSchema: Schema<any, import("mongoose").Mod
         isValid?: {} | null | undefined;
     };
     status: string;
+    content: any;
     comunication: {
         prototype?: Types.ObjectId | null | undefined;
         cacheHexString?: unknown;
@@ -85,7 +86,6 @@ export declare const EventComunicationSchema: Schema<any, import("mongoose").Mod
         isValid?: {} | null | undefined;
     };
     statusDelivery: string;
-    content: any;
     message?: string | null | undefined;
 }>, {}> & import("mongoose").FlatRecord<{} & {
     type: string;
@@ -99,6 +99,7 @@ export declare const EventComunicationSchema: Schema<any, import("mongoose").Mod
         isValid?: {} | null | undefined;
     };
     status: string;
+    content: any;
     comunication: {
         prototype?: Types.ObjectId | null | undefined;
         cacheHexString?: unknown;
@@ -109,7 +110,6 @@ export declare const EventComunicationSchema: Schema<any, import("mongoose").Mod
         isValid?: {} | null | undefined;
     };
     statusDelivery: string;
-    content: any;
     message?: string | null | undefined;
 }> & {
     _id: Types.ObjectId;

package/dist/models/TicketTransfer.d.ts

@@ -0,0 +1,74 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+import { ITicket } from "./Ticket";
+import { IAcceptTermsOfChallenge } from "./TicketOrder";
+import { IWalletMoviment } from "./WalletMoviment";
+export declare enum TicketTransferPaymentMethod {
+    WALLET = "WALLET",
+    CREDIT_CARD = "CREDIT_CARD",
+    DEBIT_CARD = "DEBIT_CARD",
+    PIX = "PIX",
+    /** Checkout InfinitePay (Pix ou cartão definidos no checkout externo). */
+    CHECKOUT = "CHECKOUT"
+}
+export declare enum TicketTransferStatus {
+    REQUESTED = "REQUESTED",
+    PROCESSING = "PROCESSING",
+    COMPLETED = "COMPLETED",
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED"
+}
+/** Tracking / conciliação InfinitePay (checkout + webhook). */
+export interface ITicketTransferInfinitePay {
+    handle?: string;
+    /** Nosso identificador enviado como Transfer_nsu (geralmente o _id do pedido). */
+    TransferNsu?: string;
+    checkoutUrl?: string;
+    invoiceSlug?: string;
+    transactionNsu?: string;
+    captureMethod?: string;
+    amountCents?: number;
+    paidAmountCents?: number;
+    installments?: number;
+    receiptUrl?: string;
+    /** pending | paid | failed | ... */
+    paymentStatus?: string;
+    webhookReceivedAt?: Date;
+    /** Último payload de webhook (auditoria / reprocessamento). */
+    lastWebhookPayload?: Record<string, unknown>;
+    checkoutCreatedAt?: Date;
+}
+export interface ITicketTransfer {
+    _id: Types.ObjectId;
+    sequenceNumber: number;
+    ticket: Types.ObjectId | ITicket;
+    accountOrigin: Types.ObjectId | IAccount;
+    accountDestination: Types.ObjectId | IAccount;
+    status: TicketTransferStatus;
+    originAccepted: boolean;
+    paymentMethod: TicketTransferPaymentMethod;
+    amount: number;
+    acceptTermsOfChallenge: IAcceptTermsOfChallenge;
+    infinitePay?: ITicketTransferInfinitePay;
+    walletMoviment?: Types.ObjectId | IWalletMoviment;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const TicketTransferInfinitePaySchema: Schema<ITicketTransferInfinitePay, import("mongoose").Model<ITicketTransferInfinitePay, any, any, any, import("mongoose").Document<unknown, any, ITicketTransferInfinitePay, any> & ITicketTransferInfinitePay & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITicketTransferInfinitePay, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITicketTransferInfinitePay>, {}> & import("mongoose").FlatRecord<ITicketTransferInfinitePay> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare const TicketTransferSchema: Schema<ITicketTransfer, import("mongoose").Model<ITicketTransfer, any, any, any, import("mongoose").Document<unknown, any, ITicketTransfer, any> & ITicketTransfer & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, ITicketTransfer, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<ITicketTransfer>, {}> & import("mongoose").FlatRecord<ITicketTransfer> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;

package/dist/models/TicketTransfer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketTransferSchema = exports.TicketTransferInfinitePaySchema = exports.TicketTransferStatus = exports.TicketTransferPaymentMethod = void 0;
+const mongoose_1 = require("mongoose");
+const TicketOrder_1 = require("./TicketOrder");
+var TicketTransferPaymentMethod;
+(function (TicketTransferPaymentMethod) {
+    TicketTransferPaymentMethod["WALLET"] = "WALLET";
+    TicketTransferPaymentMethod["CREDIT_CARD"] = "CREDIT_CARD";
+    TicketTransferPaymentMethod["DEBIT_CARD"] = "DEBIT_CARD";
+    TicketTransferPaymentMethod["PIX"] = "PIX";
+    /** Checkout InfinitePay (Pix ou cartão definidos no checkout externo). */
+    TicketTransferPaymentMethod["CHECKOUT"] = "CHECKOUT";
+})(TicketTransferPaymentMethod || (exports.TicketTransferPaymentMethod = TicketTransferPaymentMethod = {}));
+var TicketTransferStatus;
+(function (TicketTransferStatus) {
+    TicketTransferStatus["REQUESTED"] = "REQUESTED";
+    TicketTransferStatus["PROCESSING"] = "PROCESSING";
+    TicketTransferStatus["COMPLETED"] = "COMPLETED";
+    TicketTransferStatus["CANCELLED"] = "CANCELLED";
+    TicketTransferStatus["FAILED"] = "FAILED";
+})(TicketTransferStatus || (exports.TicketTransferStatus = TicketTransferStatus = {}));
+exports.TicketTransferInfinitePaySchema = new mongoose_1.Schema({
+    handle: { type: String, required: false },
+    TransferNsu: { type: String, required: false, index: true },
+    checkoutUrl: { type: String, required: false },
+    invoiceSlug: { type: String, required: false, index: true },
+    transactionNsu: { type: String, required: false, index: true },
+    captureMethod: { type: String, required: false },
+    amountCents: { type: Number, required: false },
+    paidAmountCents: { type: Number, required: false },
+    installments: { type: Number, required: false },
+    receiptUrl: { type: String, required: false },
+    paymentStatus: { type: String, required: false },
+    webhookReceivedAt: { type: Date, required: false },
+    lastWebhookPayload: { type: mongoose_1.Schema.Types.Mixed, required: false },
+    checkoutCreatedAt: { type: Date, required: false },
+}, { _id: false });
+exports.TicketTransferSchema = new mongoose_1.Schema({
+    sequenceNumber: { type: Number, required: true },
+    ticket: { type: mongoose_1.Schema.Types.ObjectId, ref: "ticket", required: true },
+    accountOrigin: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: true },
+    accountDestination: { type: mongoose_1.Schema.Types.ObjectId, ref: "account", required: true },
+    status: { type: String, required: true, enum: TicketTransferStatus },
+    originAccepted: { type: Boolean, default: false },
+    paymentMethod: { type: String, enum: TicketTransferPaymentMethod },
+    amount: { type: Number, required: true },
+    acceptTermsOfChallenge: { type: TicketOrder_1.AcceptTermsOfChallengeSchema, required: true },
+    infinitePay: { type: exports.TicketTransferInfinitePaySchema, required: false },
+    walletMoviment: { type: mongoose_1.Schema.Types.ObjectId, ref: "wallet-moviment", required: false },
+}, {
+    timestamps: {
+        createdAt: "createdAtDateTime",
+        updatedAt: "updatedAtDateTime"
+    }
+});
+exports.TicketTransferSchema.index({ accountOrigin: 1 });
+exports.TicketTransferSchema.index({ accountDestination: 1 });
+exports.TicketTransferSchema.index({ status: 1 });
+exports.TicketTransferSchema.index({ paymentMethod: 1 });
+exports.TicketTransferSchema.index({ "infinitePay.TransferNsu": 1 });
+exports.TicketTransferSchema.index({ "infinitePay.transactionNsu": 1 });

package/dist/models/WalletMoviment.d.ts

@@ -8,6 +8,7 @@ export declare enum WalletMovimentStatus {
 }
 export declare enum WalletMovimentType {
     DEPOSIT = "DEPOSIT",
+    SALE_TICKET = "SALE_TICKET",
     WITHDRAW = "WITHDRAW",
     BUY_TICKET = "BUY_TICKET",
     AWARD = "AWARD"

package/dist/models/WalletMoviment.js

@@ -12,6 +12,7 @@ var WalletMovimentStatus;
 var WalletMovimentType;
 (function (WalletMovimentType) {
     WalletMovimentType["DEPOSIT"] = "DEPOSIT";
+    WalletMovimentType["SALE_TICKET"] = "SALE_TICKET";
     WalletMovimentType["WITHDRAW"] = "WITHDRAW";
     WalletMovimentType["BUY_TICKET"] = "BUY_TICKET";
     WalletMovimentType["AWARD"] = "AWARD";

package/dist/models/WhatsAppTemplate.d.ts

@@ -0,0 +1,72 @@
+import { Schema, Types } from "mongoose";
+import { IDefault } from "./IDefault";
+export declare enum WhatsAppTemplateStatus {
+    APPROVED = "APPROVED",
+    PENDING = "PENDING",
+    REJECTED = "REJECTED",
+    PAUSED = "PAUSED",
+    DISABLED = "DISABLED",
+    IN_APPEAL = "IN_APPEAL",
+    DELETED = "DELETED"
+}
+export declare enum WhatsAppTemplateCategory {
+    MARKETING = "MARKETING",
+    UTILITY = "UTILITY",
+    AUTHENTICATION = "AUTHENTICATION"
+}
+export type WhatsAppTemplateComponentType = "HEADER" | "BODY" | "FOOTER" | "BUTTONS";
+export type WhatsAppTemplateHeaderFormat = "TEXT" | "IMAGE" | "VIDEO" | "DOCUMENT" | "LOCATION";
+export type WhatsAppTemplateVariableKind = "text" | "media";
+export interface IWhatsAppTemplateButton {
+    type?: string;
+    text?: string;
+    url?: string;
+    phoneNumber?: string;
+    example?: string[];
+}
+export interface IWhatsAppTemplateComponent {
+    type: string;
+    format?: string;
+    text?: string;
+    example?: unknown;
+    buttons?: IWhatsAppTemplateButton[];
+}
+export interface IWhatsAppTemplateVariable {
+    key: string;
+    component: string;
+    buttonIndex?: number;
+    index?: number;
+    name?: string;
+    label: string;
+    example?: string;
+    kind: WhatsAppTemplateVariableKind;
+}
+export interface IWhatsAppTemplate extends IDefault {
+    _id?: Types.ObjectId;
+    externalId?: string;
+    wabaId?: string;
+    name: string;
+    language: string;
+    status: string;
+    category?: string;
+    parameterFormat?: string;
+    qualityScore?: string;
+    rejectedReason?: string;
+    components: IWhatsAppTemplateComponent[];
+    variables: IWhatsAppTemplateVariable[];
+    lastSyncedAt?: Date;
+}
+export declare const WhatsAppTemplateSchema: Schema<IWhatsAppTemplate, import("mongoose").Model<IWhatsAppTemplate, any, any, any, import("mongoose").Document<unknown, any, IWhatsAppTemplate, any> & IWhatsAppTemplate & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, IWhatsAppTemplate, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<IWhatsAppTemplate>, {}> & import("mongoose").FlatRecord<IWhatsAppTemplate> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;
+export declare function extractPlaceholders(text?: string): string[];
+export declare function extractWhatsAppTemplateVariables(components: IWhatsAppTemplateComponent[]): IWhatsAppTemplateVariable[];
+export declare function applyWhatsAppTemplateValues(text: string | undefined, values: Record<string, string>, prefix: string): string;
+export declare function renderWhatsAppTemplateContent(template: Pick<IWhatsAppTemplate, "components" | "name">, values?: Record<string, string>): string;
+export declare function buildWhatsAppSendComponents(template: Pick<IWhatsAppTemplate, "components" | "parameterFormat">, values?: Record<string, string>): Record<string, unknown>[];

package/dist/models/WhatsAppTemplate.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppTemplateSchema = exports.WhatsAppTemplateCategory = exports.WhatsAppTemplateStatus = void 0;
+exports.extractPlaceholders = extractPlaceholders;
+exports.extractWhatsAppTemplateVariables = extractWhatsAppTemplateVariables;
+exports.applyWhatsAppTemplateValues = applyWhatsAppTemplateValues;
+exports.renderWhatsAppTemplateContent = renderWhatsAppTemplateContent;
+exports.buildWhatsAppSendComponents = buildWhatsAppSendComponents;
+const mongoose_1 = require("mongoose");
+var WhatsAppTemplateStatus;
+(function (WhatsAppTemplateStatus) {
+    WhatsAppTemplateStatus["APPROVED"] = "APPROVED";
+    WhatsAppTemplateStatus["PENDING"] = "PENDING";
+    WhatsAppTemplateStatus["REJECTED"] = "REJECTED";
+    WhatsAppTemplateStatus["PAUSED"] = "PAUSED";
+    WhatsAppTemplateStatus["DISABLED"] = "DISABLED";
+    WhatsAppTemplateStatus["IN_APPEAL"] = "IN_APPEAL";
+    WhatsAppTemplateStatus["DELETED"] = "DELETED";
+})(WhatsAppTemplateStatus || (exports.WhatsAppTemplateStatus = WhatsAppTemplateStatus = {}));
+var WhatsAppTemplateCategory;
+(function (WhatsAppTemplateCategory) {
+    WhatsAppTemplateCategory["MARKETING"] = "MARKETING";
+    WhatsAppTemplateCategory["UTILITY"] = "UTILITY";
+    WhatsAppTemplateCategory["AUTHENTICATION"] = "AUTHENTICATION";
+})(WhatsAppTemplateCategory || (exports.WhatsAppTemplateCategory = WhatsAppTemplateCategory = {}));
+const WhatsAppTemplateButtonSchema = new mongoose_1.Schema({
+    type: { type: String },
+    text: { type: String },
+    url: { type: String },
+    phoneNumber: { type: String },
+    example: [{ type: String }],
+}, { _id: false });
+const WhatsAppTemplateComponentSchema = new mongoose_1.Schema({
+    type: { type: String, required: true },
+    format: { type: String },
+    text: { type: String },
+    example: { type: mongoose_1.Schema.Types.Mixed },
+    buttons: [WhatsAppTemplateButtonSchema],
+}, { _id: false });
+const WhatsAppTemplateVariableSchema = new mongoose_1.Schema({
+    key: { type: String, required: true },
+    component: { type: String, required: true },
+    buttonIndex: { type: Number },
+    index: { type: Number },
+    name: { type: String },
+    label: { type: String, required: true },
+    example: { type: String },
+    kind: { type: String, enum: ["text", "media"], required: true, default: "text" },
+}, { _id: false });
+exports.WhatsAppTemplateSchema = new mongoose_1.Schema({
+    externalId: { type: String },
+    wabaId: { type: String },
+    name: { type: String, required: true },
+    language: { type: String, required: true },
+    status: { type: String, required: true },
+    category: { type: String },
+    parameterFormat: { type: String },
+    qualityScore: { type: String },
+    rejectedReason: { type: String },
+    components: { type: [WhatsAppTemplateComponentSchema], default: [] },
+    variables: { type: [WhatsAppTemplateVariableSchema], default: [] },
+    lastSyncedAt: { type: Date },
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" },
+});
+exports.WhatsAppTemplateSchema.index({ name: 1, language: 1 }, { unique: true });
+exports.WhatsAppTemplateSchema.index({ status: 1, name: 1 });
+exports.WhatsAppTemplateSchema.index({ externalId: 1 });
+const PLACEHOLDER_RE = /\{\{\s*([a-zA-Z_][\w]*|\d+)\s*\}\}/g;
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function firstExampleString(example, fallbackIndex = 0) {
+    const record = asRecord(example);
+    const headerText = record.header_text;
+    if (Array.isArray(headerText) && headerText[fallbackIndex] != null)
+        return String(headerText[fallbackIndex]);
+    const headerHandle = record.header_handle;
+    if (Array.isArray(headerHandle) && headerHandle[0] != null)
+        return String(headerHandle[0]);
+    const bodyText = record.body_text;
+    if (Array.isArray(bodyText) && Array.isArray(bodyText[0]) && bodyText[0][fallbackIndex] != null) {
+        return String(bodyText[0][fallbackIndex]);
+    }
+    const named = record.body_text_named_params;
+    if (Array.isArray(named) && named[fallbackIndex]) {
+        const row = asRecord(named[fallbackIndex]);
+        if (row.example != null)
+            return String(row.example);
+    }
+    const headerNamed = record.header_text_named_params;
+    if (Array.isArray(headerNamed) && headerNamed[fallbackIndex]) {
+        const row = asRecord(headerNamed[fallbackIndex]);
+        if (row.example != null)
+            return String(row.example);
+    }
+    return undefined;
+}
+function extractPlaceholders(text) {
+    if (!text)
+        return [];
+    const found = [];
+    const seen = new Set();
+    const re = new RegExp(PLACEHOLDER_RE.source, "g");
+    let match;
+    while ((match = re.exec(text))) {
+        const token = match[1];
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        found.push(token);
+    }
+    return found;
+}
+function placeholderLabel(component, token, kind) {
+    if (kind === "media") {
+        if (component === "HEADER")
+            return "Mídia do cabeçalho (URL)";
+        return `Mídia (${component})`;
+    }
+    const where = component === "HEADER" ? "cabeçalho" : component === "BODY" ? "corpo" : component === "BUTTON" ? "botão" : component.toLowerCase();
+    return isNaN(Number(token)) ? `${where}: {{${token}}}` : `${where} {{${token}}}`;
+}
+function extractWhatsAppTemplateVariables(components) {
+    const variables = [];
+    for (const component of components) {
+        const type = String(component.type || "").toUpperCase();
+        if (type === "HEADER") {
+            const format = String(component.format || "TEXT").toUpperCase();
+            if (format === "IMAGE" || format === "VIDEO" || format === "DOCUMENT") {
+                variables.push({
+                    key: "header.media",
+                    component: "HEADER",
+                    label: placeholderLabel("HEADER", "media", "media"),
+                    example: firstExampleString(component.example),
+                    kind: "media",
+                });
+            }
+        }
+        if (type === "HEADER" || type === "BODY") {
+            const tokens = extractPlaceholders(component.text);
+            tokens.forEach((token, order) => {
+                const index = Number(token);
+                variables.push({
+                    key: `${type.toLowerCase()}.${token}`,
+                    component: type,
+                    index: Number.isFinite(index) ? index : order + 1,
+                    name: Number.isFinite(index) ? undefined : token,
+                    label: placeholderLabel(type, token, "text"),
+                    example: firstExampleString(component.example, Number.isFinite(index) ? index - 1 : order),
+                    kind: "text",
+                });
+            });
+        }
+        if (type === "BUTTONS") {
+            (component.buttons || []).forEach((button, buttonIndex) => {
+                const tokens = extractPlaceholders(button.url);
+                tokens.forEach((token, order) => {
+                    const index = Number(token);
+                    variables.push({
+                        key: `button.${buttonIndex}.${token}`,
+                        component: "BUTTON",
+                        buttonIndex,
+                        index: Number.isFinite(index) ? index : order + 1,
+                        name: Number.isFinite(index) ? undefined : token,
+                        label: `botão ${button.text || buttonIndex + 1} {{${token}}}`,
+                        example: button.example?.[order],
+                        kind: "text",
+                    });
+                });
+            });
+        }
+    }
+    return variables;
+}
+function applyWhatsAppTemplateValues(text, values, prefix) {
+    if (!text)
+        return "";
+    return text.replace(PLACEHOLDER_RE, (_full, token) => {
+        const exact = values[`${prefix}.${token}`];
+        if (exact != null && exact !== "")
+            return exact;
+        const byToken = values[token];
+        if (byToken != null && byToken !== "")
+            return byToken;
+        return `{{${token}}}`;
+    });
+}
+function renderWhatsAppTemplateContent(template, values = {}) {
+    const parts = [];
+    for (const component of template.components || []) {
+        const type = String(component.type || "").toUpperCase();
+        if (type === "HEADER") {
+            const format = String(component.format || "TEXT").toUpperCase();
+            if (format === "TEXT") {
+                const text = applyWhatsAppTemplateValues(component.text, values, "header");
+                if (text)
+                    parts.push(text);
+            }
+            else if (values["header.media"]) {
+                parts.push(values["header.media"]);
+            }
+        }
+        if (type === "BODY") {
+            const text = applyWhatsAppTemplateValues(component.text, values, "body");
+            if (text)
+                parts.push(text);
+        }
+        if (type === "FOOTER" && component.text) {
+            parts.push(component.text);
+        }
+        if (type === "BUTTONS") {
+            for (const button of component.buttons || []) {
+                if (button.text)
+                    parts.push(button.text);
+            }
+        }
+    }
+    return parts.join("\n\n").trim() || template.name;
+}
+function buildWhatsAppSendComponents(template, values = {}) {
+    const named = String(template.parameterFormat || "").toUpperCase() === "NAMED";
+    const payload = [];
+    for (const component of template.components || []) {
+        const type = String(component.type || "").toUpperCase();
+        if (type === "HEADER") {
+            const format = String(component.format || "TEXT").toUpperCase();
+            if (format === "IMAGE" || format === "VIDEO" || format === "DOCUMENT") {
+                const link = values["header.media"];
+                if (link) {
+                    const mediaType = format.toLowerCase();
+                    payload.push({
+                        type: "header",
+                        parameters: [{ type: mediaType, [mediaType]: { link } }],
+                    });
+                }
+                continue;
+            }
+            const tokens = extractPlaceholders(component.text);
+            if (!tokens.length)
+                continue;
+            payload.push({
+                type: "header",
+                parameters: tokens.map((token) => parameterOf(token, values, "header", named)),
+            });
+        }
+        if (type === "BODY") {
+            const tokens = extractPlaceholders(component.text);
+            if (!tokens.length)
+                continue;
+            payload.push({
+                type: "body",
+                parameters: tokens.map((token) => parameterOf(token, values, "body", named)),
+            });
+        }
+        if (type === "BUTTONS") {
+            (component.buttons || []).forEach((button, buttonIndex) => {
+                const tokens = extractPlaceholders(button.url);
+                if (!tokens.length)
+                    return;
+                payload.push({
+                    type: "button",
+                    sub_type: "url",
+                    index: String(buttonIndex),
+                    parameters: tokens.map((token) => ({
+                        type: "text",
+                        text: values[`button.${buttonIndex}.${token}`] || values[token] || "",
+                    })),
+                });
+            });
+        }
+    }
+    return payload;
+}
+function parameterOf(token, values, prefix, named) {
+    const text = values[`${prefix}.${token}`] || values[token] || "";
+    if (named && isNaN(Number(token))) {
+        return { type: "text", parameter_name: token, text };
+    }
+    return { type: "text", text };
+}

package/dist/models/index.d.ts

@@ -1,10 +1,9 @@
 export * from "./Access";
 export * from "./Account";
 export * from "./AccountDeletionRequest";
-export * from "./AdminAccount";
 export * from "./AdminAccessProfile";
+export * from "./AdminAccount";
 export * from "./AdminComunication";
-export * from "./EventComunication";
 export * from "./AdminTemplateEmail";
 export * from "./AdminTemplatePush";
 export * from "./Challenge";
@@ -17,9 +16,12 @@ export * from "./ChampionshipRound";
 export * from "./Chat";
 export * from "./ChatMessage";
 export * from "./Contact";
+export * from "./EventComunication";
 export * from "./File";
 export * from "./Team";
 export * from "./Ticket";
 export * from "./TicketGuess";
 export * from "./TicketOrder";
+export * from "./TicketTransfer";
 export * from "./WalletMoviment";
+export * from "./WhatsAppTemplate";

package/dist/models/index.js

@@ -17,10 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Access"), exports);
 __exportStar(require("./Account"), exports);
 __exportStar(require("./AccountDeletionRequest"), exports);
-__exportStar(require("./AdminAccount"), exports);
 __exportStar(require("./AdminAccessProfile"), exports);
+__exportStar(require("./AdminAccount"), exports);
 __exportStar(require("./AdminComunication"), exports);
-__exportStar(require("./EventComunication"), exports);
 __exportStar(require("./AdminTemplateEmail"), exports);
 __exportStar(require("./AdminTemplatePush"), exports);
 __exportStar(require("./Challenge"), exports);
@@ -33,9 +32,12 @@ __exportStar(require("./ChampionshipRound"), exports);
 __exportStar(require("./Chat"), exports);
 __exportStar(require("./ChatMessage"), exports);
 __exportStar(require("./Contact"), exports);
+__exportStar(require("./EventComunication"), exports);
 __exportStar(require("./File"), exports);
 __exportStar(require("./Team"), exports);
 __exportStar(require("./Ticket"), exports);
 __exportStar(require("./TicketGuess"), exports);
 __exportStar(require("./TicketOrder"), exports);
+__exportStar(require("./TicketTransfer"), exports);
 __exportStar(require("./WalletMoviment"), exports);
+__exportStar(require("./WhatsAppTemplate"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-desafiox",
-  "version": "1.0.136",
+  "version": "1.0.143",
   "description": "Modelagem TypeScript/Mongoose para o jogo Escalada X (times, campeonatos, fases, rodadas, confrontos, desafios)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",