c2-climbing-x 1.0.95 → 1.0.97

package/dist/models/AccountNotification.d.ts

@@ -1,16 +1,16 @@
 import { Schema, Types } from "mongoose";
 import { IAccount } from "./Account";
 import { IAdminNotification } from "./AdminNotification";
-export declare enum AccountPushNotificationStatus {
+export declare enum AccountNotificationStatus {
     CREATED = "CREATED",
     SENT = "SENT",
     DELIVERED = "DELIVERED",
     READ = "READ"
 }
-export interface IAccountPushNotification {
+export interface IAccountNotification {
     account: Types.ObjectId | IAccount;
     adminNotification: Types.ObjectId | IAdminNotification;
-    status: AccountPushNotificationStatus;
+    status: AccountNotificationStatus;
     push: boolean;
     title: string;
     message: string;
@@ -19,7 +19,7 @@ export interface IAccountPushNotification {
     createdAtDateTime: Date;
     updatedAtDateTime: Date;
 }
-export declare const AccountPushNotificationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+export declare const AccountNotificationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
     timestamps: {
         createdAt: string;
         updatedAt: string;

package/dist/models/AccountNotification.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccountPushNotificationSchema = exports.AccountPushNotificationStatus = void 0;
+exports.AccountNotificationSchema = exports.AccountNotificationStatus = void 0;
 const mongoose_1 = require("mongoose");
-var AccountPushNotificationStatus;
-(function (AccountPushNotificationStatus) {
-    AccountPushNotificationStatus["CREATED"] = "CREATED";
-    AccountPushNotificationStatus["SENT"] = "SENT";
-    AccountPushNotificationStatus["DELIVERED"] = "DELIVERED";
-    AccountPushNotificationStatus["READ"] = "READ";
-})(AccountPushNotificationStatus || (exports.AccountPushNotificationStatus = AccountPushNotificationStatus = {}));
-exports.AccountPushNotificationSchema = new mongoose_1.Schema({
+var AccountNotificationStatus;
+(function (AccountNotificationStatus) {
+    AccountNotificationStatus["CREATED"] = "CREATED";
+    AccountNotificationStatus["SENT"] = "SENT";
+    AccountNotificationStatus["DELIVERED"] = "DELIVERED";
+    AccountNotificationStatus["READ"] = "READ";
+})(AccountNotificationStatus || (exports.AccountNotificationStatus = AccountNotificationStatus = {}));
+exports.AccountNotificationSchema = new mongoose_1.Schema({
     account: { type: mongoose_1.Types.ObjectId, ref: "account", required: true },
     adminNotification: { type: mongoose_1.Types.ObjectId, ref: "admin-notification", required: true },
-    status: { type: String, enum: AccountPushNotificationStatus, required: true, default: AccountPushNotificationStatus.CREATED },
+    status: { type: String, enum: AccountNotificationStatus, required: true, default: AccountNotificationStatus.CREATED },
     push: { type: Boolean, required: true, default: false },
     title: { type: String, required: true },
     message: { type: String, required: true },

package/dist/models/AdminComunication.d.ts

@@ -0,0 +1,97 @@
+import { Schema, Types } from "mongoose";
+import { IAdminTemplatePush } from "./AdminTemplatePush";
+import { IAdminTemplateEmail } from "./AdminTemplateEmail";
+export declare enum AdminComunicationStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export interface IAdminComunication {
+    name: string;
+    description?: string;
+    templateEmail?: Types.ObjectId | IAdminTemplateEmail;
+    templatePush?: Types.ObjectId | IAdminTemplatePush;
+    status: AdminComunicationStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminComunicationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    description?: string | undefined;
+    templateEmail?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    } | undefined;
+    templatePush?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    } | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    description?: string | undefined;
+    templateEmail?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    } | undefined;
+    templatePush?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    } | undefined;
+}>> & import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    description?: string | undefined;
+    templateEmail?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    } | undefined;
+    templatePush?: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    } | undefined;
+}> & {
+    _id: Types.ObjectId;
+}>;

package/dist/models/AdminComunication.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminComunicationSchema = exports.AdminComunicationStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AdminComunicationStatus;
+(function (AdminComunicationStatus) {
+    AdminComunicationStatus["DRAFT"] = "DRAFT";
+    AdminComunicationStatus["ACTIVE"] = "ACTIVE";
+    AdminComunicationStatus["INACTIVE"] = "INACTIVE";
+})(AdminComunicationStatus || (exports.AdminComunicationStatus = AdminComunicationStatus = {}));
+exports.AdminComunicationSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    description: { type: String, required: false },
+    templateEmail: { type: mongoose_1.Types.ObjectId, ref: "admin-template-email", required: false },
+    templatePush: { type: mongoose_1.Types.ObjectId, ref: "admin-template-push", required: false },
+    status: { type: String, enum: AdminComunicationStatus, required: true, default: AdminComunicationStatus.DRAFT },
+    createdAtDateTime: { type: Date, required: true },
+    updatedAtDateTime: { type: Date, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminComunicationSchema.index({ name: 1 }, { unique: true });

package/dist/models/AdminEventComunication.d.ts

@@ -0,0 +1,234 @@
+import { Schema, Types } from "mongoose";
+import { IAccount } from "./Account";
+import { IAdminComunication } from "./AdminComunication";
+import { IFile } from "./File";
+import { IAdminTemplatePush } from "./AdminTemplatePush";
+import { IAdminTemplateEmail } from "./AdminTemplateEmail";
+export declare enum AdminEventComunicationStatus {
+    CREATED = "CREATED",
+    RUNNING = "RUNNING",
+    ERROR = "ERROR",
+    DONE = "DONE"
+}
+export declare enum AdminMessageStatus {
+    CREATED = "CREATED",
+    SENT = "SENT",
+    DELIVERED = "DELIVERED",
+    READ = "READ"
+}
+export interface IAccountNotification {
+    account: Types.ObjectId | IAccount;
+    comunication: Types.ObjectId | IAdminComunication;
+    pushContent?: {
+        template: Types.ObjectId | IAdminTemplatePush;
+        status: AdminMessageStatus;
+        title: string;
+        message: string;
+        image?: IFile;
+        redirect?: string;
+        metadata?: Map<string, string>;
+    };
+    emailContent?: {
+        template: Types.ObjectId | IAdminTemplateEmail;
+        status: AdminMessageStatus;
+        subject: string;
+        bodyHtml: string;
+    };
+    status: AdminEventComunicationStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AccountNotificationSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    account: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    status: string;
+    comunication: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    pushContent?: {
+        message: string;
+        status: string;
+        title: string;
+        template: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        };
+        image?: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        } | undefined;
+        redirect?: string | undefined;
+        metadata?: Map<string, string> | undefined;
+    } | undefined;
+    emailContent?: {
+        status: string;
+        subject: string;
+        bodyHtml: string;
+        template: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        };
+        addresses: string[];
+    } | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    account: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    status: string;
+    comunication: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    pushContent?: {
+        message: string;
+        status: string;
+        title: string;
+        template: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        };
+        image?: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        } | undefined;
+        redirect?: string | undefined;
+        metadata?: Map<string, string> | undefined;
+    } | undefined;
+    emailContent?: {
+        status: string;
+        subject: string;
+        bodyHtml: string;
+        template: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        };
+        addresses: string[];
+    } | undefined;
+}>> & import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    account: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    status: string;
+    comunication: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        createFromBase64?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    pushContent?: {
+        message: string;
+        status: string;
+        title: string;
+        template: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        };
+        image?: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        } | undefined;
+        redirect?: string | undefined;
+        metadata?: Map<string, string> | undefined;
+    } | undefined;
+    emailContent?: {
+        status: string;
+        subject: string;
+        bodyHtml: string;
+        template: {
+            prototype?: Types.ObjectId | undefined;
+            cacheHexString?: unknown;
+            generate?: {} | undefined;
+            createFromTime?: {} | undefined;
+            createFromHexString?: {} | undefined;
+            createFromBase64?: {} | undefined;
+            isValid?: {} | undefined;
+        };
+        addresses: string[];
+    } | undefined;
+}> & {
+    _id: Types.ObjectId;
+}>;

package/dist/models/AdminEventComunication.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountNotificationSchema = exports.AdminMessageStatus = exports.AdminEventComunicationStatus = void 0;
+const mongoose_1 = require("mongoose");
+const AdminTemplatePush_1 = require("./AdminTemplatePush");
+const AdminTemplateEmail_1 = require("./AdminTemplateEmail");
+var AdminEventComunicationStatus;
+(function (AdminEventComunicationStatus) {
+    AdminEventComunicationStatus["CREATED"] = "CREATED";
+    AdminEventComunicationStatus["RUNNING"] = "RUNNING";
+    AdminEventComunicationStatus["ERROR"] = "ERROR";
+    AdminEventComunicationStatus["DONE"] = "DONE";
+})(AdminEventComunicationStatus || (exports.AdminEventComunicationStatus = AdminEventComunicationStatus = {}));
+var AdminMessageStatus;
+(function (AdminMessageStatus) {
+    AdminMessageStatus["CREATED"] = "CREATED";
+    AdminMessageStatus["SENT"] = "SENT";
+    AdminMessageStatus["DELIVERED"] = "DELIVERED";
+    AdminMessageStatus["READ"] = "READ";
+})(AdminMessageStatus || (exports.AdminMessageStatus = AdminMessageStatus = {}));
+exports.AccountNotificationSchema = new mongoose_1.Schema({
+    account: { type: mongoose_1.Types.ObjectId, ref: "account", required: true },
+    comunication: { type: mongoose_1.Types.ObjectId, ref: "admin-comunication", required: true },
+    pushContent: {
+        type: {
+            template: { type: mongoose_1.Types.ObjectId, ref: "admin-template-push", required: true },
+            status: { type: String, enum: AdminTemplatePush_1.AdminTemplatePushStatus, required: true, default: AdminTemplatePush_1.AdminTemplatePushStatus.DRAFT },
+            title: { type: String, required: true },
+            message: { type: String, required: true },
+            image: { type: mongoose_1.Types.ObjectId, ref: "file", required: false },
+            redirect: { type: String, required: false },
+            metadata: { type: Map, of: String, required: false }
+        },
+        required: false
+    },
+    emailContent: {
+        type: {
+            template: { type: mongoose_1.Types.ObjectId, ref: "admin-template-email", required: true },
+            status: { type: String, enum: AdminTemplateEmail_1.AdminTemplateEmailStatus, required: true, default: AdminTemplateEmail_1.AdminTemplateEmailStatus.DRAFT },
+            subject: { type: String, required: true },
+            bodyHtml: { type: String, required: true },
+            addresses: { type: [String], required: true }
+        },
+        required: false
+    },
+    status: { type: String, enum: AdminEventComunicationStatus, required: true, default: AdminEventComunicationStatus.CREATED },
+    createdAtDateTime: { type: Date, required: true },
+    updatedAtDateTime: { type: Date, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AccountNotificationSchema.index({ account: 1 }, { unique: false });
+exports.AccountNotificationSchema.index({ account: 1, status: 1 }, { unique: false });

package/dist/models/AdminTemplateEmail.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "mongoose";
+export declare enum AdminTemplateEmailStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export interface IAdminTemplateEmail {
+    name: string;
+    subject: string;
+    bodyHtml: string;
+    status: AdminTemplateEmailStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminTemplateEmailSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    subject: string;
+    bodyHtml: string;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    subject: string;
+    bodyHtml: string;
+}>> & import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    subject: string;
+    bodyHtml: string;
+}> & {
+    _id: import("mongoose").Types.ObjectId;
+}>;

package/dist/models/AdminTemplateEmail.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTemplateEmailSchema = exports.AdminTemplateEmailStatus = void 0;
+const mongoose_1 = require("mongoose");
+var AdminTemplateEmailStatus;
+(function (AdminTemplateEmailStatus) {
+    AdminTemplateEmailStatus["DRAFT"] = "DRAFT";
+    AdminTemplateEmailStatus["ACTIVE"] = "ACTIVE";
+    AdminTemplateEmailStatus["INACTIVE"] = "INACTIVE";
+})(AdminTemplateEmailStatus || (exports.AdminTemplateEmailStatus = AdminTemplateEmailStatus = {}));
+exports.AdminTemplateEmailSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    subject: { type: String, required: true },
+    bodyHtml: { type: String, required: true },
+    status: { type: String, enum: AdminTemplateEmailStatus, required: true, default: AdminTemplateEmailStatus.DRAFT },
+    createdAtDateTime: { type: Date, required: true },
+    updatedAtDateTime: { type: Date, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminTemplateEmailSchema.index({ name: 1 }, { unique: true });

package/dist/models/AdminTemplatePush.d.ts

@@ -0,0 +1,71 @@
+import { Schema, Types } from "mongoose";
+import { IFile } from "./File";
+export declare enum AdminTemplatePushStatus {
+    DRAFT = "DRAFT",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+export interface IAdminTemplatePush {
+    name: string;
+    title: string;
+    body: string;
+    image?: IFile;
+    redirect?: string;
+    metadata?: Map<string, string>;
+    status: AdminTemplatePushStatus;
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+}
+export declare const AdminTemplatePushSchema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+}, {
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    title: string;
+    body: string;
+    image?: {
+        contentType: string;
+        description: string;
+        format?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    title: string;
+    body: string;
+    image?: {
+        contentType: string;
+        description: string;
+        format?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+}>> & import("mongoose").FlatRecord<{
+    createdAtDateTime: Date;
+    updatedAtDateTime: Date;
+    name: string;
+    status: string;
+    title: string;
+    body: string;
+    image?: {
+        contentType: string;
+        description: string;
+        format?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    redirect?: string | undefined;
+    metadata?: Map<string, string> | undefined;
+}> & {
+    _id: Types.ObjectId;
+}>;

package/dist/models/AdminTemplatePush.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminTemplatePushSchema = exports.AdminTemplatePushStatus = void 0;
+const mongoose_1 = require("mongoose");
+const File_1 = require("./File");
+var AdminTemplatePushStatus;
+(function (AdminTemplatePushStatus) {
+    AdminTemplatePushStatus["DRAFT"] = "DRAFT";
+    AdminTemplatePushStatus["ACTIVE"] = "ACTIVE";
+    AdminTemplatePushStatus["INACTIVE"] = "INACTIVE";
+})(AdminTemplatePushStatus || (exports.AdminTemplatePushStatus = AdminTemplatePushStatus = {}));
+exports.AdminTemplatePushSchema = new mongoose_1.Schema({
+    name: { type: String, required: true },
+    title: { type: String, required: true },
+    body: { type: String, required: true },
+    image: { type: File_1.FileSchema, required: false },
+    redirect: { type: String, required: false },
+    metadata: { type: Map, of: String, required: false },
+    status: { type: String, enum: AdminTemplatePushStatus, required: true, default: AdminTemplatePushStatus.DRAFT },
+    createdAtDateTime: { type: Date, required: true },
+    updatedAtDateTime: { type: Date, required: true }
+}, {
+    timestamps: { createdAt: "createdAtDateTime", updatedAt: "updatedAtDateTime" }
+});
+exports.AdminTemplatePushSchema.index({ name: 1 }, { unique: true });

package/dist/models/index.d.ts

@@ -8,8 +8,8 @@ export * from "./ChampionshipMatch";
 export * from "./ChampionshipPhase";
 export * from "./ChampionshipRound";
 export * from "./File";
-export * from "./AdminNotification";
-export * from "./AccountNotification";
+export * from "./AdminComunication";
+export * from "./AdminEventComunication";
 export * from "./Team";
 export * from "./Ticket";
 export * from "./TicketGuess";

package/dist/models/index.js

@@ -24,8 +24,8 @@ __exportStar(require("./ChampionshipMatch"), exports);
 __exportStar(require("./ChampionshipPhase"), exports);
 __exportStar(require("./ChampionshipRound"), exports);
 __exportStar(require("./File"), exports);
-__exportStar(require("./AdminNotification"), exports);
-__exportStar(require("./AccountNotification"), exports);
+__exportStar(require("./AdminComunication"), exports);
+__exportStar(require("./AdminEventComunication"), exports);
 __exportStar(require("./Team"), exports);
 __exportStar(require("./Ticket"), exports);
 __exportStar(require("./TicketGuess"), exports);

package/package.json

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