@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/models/Communication/types.d.ts

@@ -0,0 +1,63 @@
+import { DocumentReference, Timestamp } from '@google-cloud/firestore';
+import { Descendant } from '../../helpers/slate';
+import { CommunicationTemplateType } from '../../helpers/communicationTemplate';
+import { GroupTinyData } from '../Group/types';
+import { UserTinyData } from '../User/types';
+export declare enum CommunicationType {
+    Private = "user",
+    Public = "group"
+}
+export declare enum CommunicationReactions {
+    OK = "\uD83D\uDC4D",
+    Claps = "\uD83D\uDC4F",
+    Muscle = "\uD83D\uDCAA",
+    LOL = "\uD83D\uDE02",
+    HeartFace = "\uD83D\uDE0D",
+    Cool = "\uD83D\uDE0E",
+    Sad = "\uD83D\uDE22",
+    Sick = "\uD83E\uDD12",
+    Eyes = "\uD83D\uDC40",
+    Check = "\u2705",
+    Hearth = "\u2764\uFE0F",
+    Party = "\uD83C\uDF89",
+    Fire = "\uD83D\uDD25",
+    Rocket = "\uD83D\uDE80",
+    Car = "\uD83D\uDE97"
+}
+export interface CommunicationRecipientData {
+    sendedAt: Timestamp;
+    /** @deprecated use reaction */
+    claps: number;
+    viewedAt: Timestamp | null;
+    lastViewedAt: Timestamp | null;
+    countViews: number;
+    reaction: CommunicationReactions | null;
+}
+export interface CommunicationData {
+    title: string;
+    message: Descendant[];
+    messageMd: string;
+    type: CommunicationType;
+    readonly promoter: DocumentReference;
+    promoterInfo: GroupTinyData;
+    readonly owner: DocumentReference;
+    ownerInfo: GroupTinyData | UserTinyData;
+    blockAnswers: boolean;
+    attachmentsPath: string[];
+    imagesPath: string[];
+    templateId: string | null;
+    recipients: string[];
+    recipientsInfo: Record<string, CommunicationRecipientData>;
+    commentsCount: number;
+    deletedAt: Timestamp | null;
+    deletedBy: string | null;
+    editedAt: Timestamp | null;
+    editedBy: string | null;
+    serverTemplate: CommunicationTemplateType | null;
+    serverTemplateVars: {
+        title: Record<string, string>;
+        message: Record<string, string>;
+    } | null;
+    readonly server: boolean;
+    readonly createdAt: Timestamp;
+}

package/models/Communication/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunicationReactions = exports.CommunicationType = void 0;
+var CommunicationType;
+(function (CommunicationType) {
+    CommunicationType["Private"] = "user";
+    CommunicationType["Public"] = "group";
+})(CommunicationType || (exports.CommunicationType = CommunicationType = {}));
+var CommunicationReactions;
+(function (CommunicationReactions) {
+    CommunicationReactions["OK"] = "\uD83D\uDC4D";
+    CommunicationReactions["Claps"] = "\uD83D\uDC4F";
+    CommunicationReactions["Muscle"] = "\uD83D\uDCAA";
+    CommunicationReactions["LOL"] = "\uD83D\uDE02";
+    CommunicationReactions["HeartFace"] = "\uD83D\uDE0D";
+    CommunicationReactions["Cool"] = "\uD83D\uDE0E";
+    CommunicationReactions["Sad"] = "\uD83D\uDE22";
+    CommunicationReactions["Sick"] = "\uD83E\uDD12";
+    CommunicationReactions["Eyes"] = "\uD83D\uDC40";
+    CommunicationReactions["Check"] = "\u2705";
+    CommunicationReactions["Hearth"] = "\u2764\uFE0F";
+    CommunicationReactions["Party"] = "\uD83C\uDF89";
+    CommunicationReactions["Fire"] = "\uD83D\uDD25";
+    CommunicationReactions["Rocket"] = "\uD83D\uDE80";
+    CommunicationReactions["Car"] = "\uD83D\uDE97";
+})(CommunicationReactions || (exports.CommunicationReactions = CommunicationReactions = {}));

package/models/CompositionGenre/index.d.ts

@@ -0,0 +1,9 @@
+import { LanguagesTypes } from '../../lang';
+import { CompositionGenreTreeKey } from '../../helpers/compositionCategories';
+export default class CompositionGenre {
+    id: CompositionGenreTreeKey;
+    private lang;
+    private treeNode;
+    constructor(id: CompositionGenreTreeKey, lang?: LanguagesTypes);
+    get name(): string;
+}

package/models/CompositionGenre/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../lang");
+const compositionCategories_1 = require("../../helpers/compositionCategories");
+class CompositionGenre {
+    constructor(id, lang = lang_1.defaultLocale) {
+        this.id = id;
+        this.lang = lang;
+        this.treeNode = compositionCategories_1.compositionGenresTree[id];
+    }
+    get name() {
+        const translation = (0, lang_1.getTranslation)(this.treeNode.labelKey, this.lang);
+        return translation || this.treeNode.labelKey;
+    }
+}
+exports.default = CompositionGenre;

package/models/CompositionStyle/index.d.ts

@@ -0,0 +1,9 @@
+import { CompositionStyleTreeKey } from '../../helpers/compositionCategories';
+import { LanguagesTypes } from '../../lang';
+export default class CompositionStyle {
+    id: CompositionStyleTreeKey;
+    private lang;
+    private treeNode;
+    constructor(id: CompositionStyleTreeKey, lang?: LanguagesTypes);
+    get name(): string;
+}

package/models/CompositionStyle/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compositionCategories_1 = require("../../helpers/compositionCategories");
+const lang_1 = require("../../lang");
+class CompositionStyle {
+    constructor(id, lang = lang_1.defaultLocale) {
+        this.id = id;
+        this.lang = lang;
+        this.treeNode = compositionCategories_1.compositionStylesTree[id];
+    }
+    get name() {
+        const translation = (0, lang_1.getTranslation)(this.treeNode.labelKey, this.lang);
+        return translation || this.treeNode.labelKey;
+    }
+}
+exports.default = CompositionStyle;

package/models/Counters/Group/Analytics/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SatisfactionIndexElements = void 0;
+var SatisfactionIndexElements;
+(function (SatisfactionIndexElements) {
+    SatisfactionIndexElements["ROLLCALLED_EVENTS_RATIO"] = "ROLLCALLED_EVENTS_RATIO";
+    SatisfactionIndexElements["ADMIN_COUNT"] = "ADMIN_COUNT";
+    SatisfactionIndexElements["MEMBERS_COUNT"] = "MEMBERS_COUNT";
+    SatisfactionIndexElements["EVENTS_PER_WEEK"] = "EVENTS_PER_WEEK";
+    SatisfactionIndexElements["ATTENDANCE_PREVISION_RATIO"] = "ATTENDANCE_PREVISION_RATIO";
+    SatisfactionIndexElements["EVENTS_ANSWER_PERCENTAGE"] = "EVENTS_ANSWER_PERCENTAGE";
+    SatisfactionIndexElements["EVENTS_WITH_REPERTORY_PERCENTAGE"] = "EVENTS_WITH_REPERTORY_PERCENTAGE";
+    SatisfactionIndexElements["REPERTORY_COUNT"] = "REPERTORY_COUNT";
+    SatisfactionIndexElements["COMMUNICATION_COUNT"] = "COMMUNICATION_COUNT";
+    SatisfactionIndexElements["EVENTS_COUNT"] = "EVENTS_COUNT";
+    SatisfactionIndexElements["EVENTS_FUTURE_COUNT"] = "EVENTS_FUTURE_COUNT";
+})(SatisfactionIndexElements || (exports.SatisfactionIndexElements = SatisfactionIndexElements = {}));

package/models/Customer/index.d.ts

@@ -0,0 +1,30 @@
+import { AdminItemStatus } from '../../helpers/types';
+import { DocumentModel } from '../Model';
+import CustomerBasic from './basic';
+import { CustomerData } from './types';
+export default class Customer extends CustomerBasic<CustomerData> {
+    constructor(doc: DocumentModel);
+    get admins(): string[];
+    get adminList(): import("../../helpers/types").AdminItem[];
+    get pendingAdmins(): import("../../helpers/types").AdminItem[];
+    get confirmedAdmins(): import("../../helpers/types").AdminItem[];
+    adminListByStatus(status: AdminItemStatus): import("../../helpers/types").AdminItem[];
+    isAdmin(userId: string): boolean;
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get deletedBy(): string | null;
+    get isDeleted(): boolean;
+    get isActive(): boolean;
+    get gocardlessId(): string | null;
+    get stripeId(): string | null;
+    get stripeTaxIds(): {
+        type: string;
+        value: string;
+    }[];
+    get howDidYouHearAboutUs(): string | null;
+    get groupIds(): string[];
+    getGlissandooAdminUrl(adminHost: string): string;
+    get mrr(): number;
+    get manual(): boolean;
+    get notes(): string | null;
+}

package/models/Customer/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const collections_1 = require("../../helpers/collections");
+const externalUrls_1 = require("../../helpers/externalUrls");
+const types_1 = require("../../helpers/types");
+const basic_1 = __importDefault(require("./basic"));
+class Customer extends basic_1.default {
+    constructor(doc) {
+        super(doc);
+    }
+    get admins() {
+        return this.data.administrators || [];
+    }
+    get adminList() {
+        return this.data.administratorsList || [];
+    }
+    get pendingAdmins() {
+        return this.adminList.filter((item) => item.status === types_1.AdminItemStatus.Pending);
+    }
+    get confirmedAdmins() {
+        return this.adminList.filter((item) => item.status === types_1.AdminItemStatus.Accepted);
+    }
+    adminListByStatus(status) {
+        if (status === types_1.AdminItemStatus.Pending)
+            return this.pendingAdmins;
+        if (status === types_1.AdminItemStatus.Accepted)
+            return this.confirmedAdmins;
+        return this.adminList.filter((item) => item.status === status);
+    }
+    isAdmin(userId) {
+        return this.admins.includes(userId);
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get deletedAt() {
+        return this.data.deletedAt || null;
+    }
+    get deletedBy() {
+        return this.data.deletedBy || null;
+    }
+    get isDeleted() {
+        return this.deletedAt !== null;
+    }
+    get isActive() {
+        return this.exists && !this.deletedAt;
+    }
+    get gocardlessId() {
+        return this.data.gocardlessId || null;
+    }
+    get stripeId() {
+        return this.data.stripeId || null;
+    }
+    get stripeTaxIds() {
+        return this.data.stripeTaxIds || [];
+    }
+    get howDidYouHearAboutUs() {
+        return this.data.howDidYouHearAboutUs || null;
+    }
+    get groupIds() {
+        return this.data.groupIds || [];
+    }
+    getGlissandooAdminUrl(adminHost) {
+        return (0, externalUrls_1.buildAdminEntityUrl)(adminHost, collections_1.CollectionNames.Customer, this.id);
+    }
+    get mrr() {
+        return this.data.mrr || 0;
+    }
+    get manual() {
+        return this.data.manual || false;
+    }
+    get notes() {
+        return this.data.notes || null;
+    }
+}
+exports.default = Customer;

package/models/Customer/types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerRoles = void 0;
+var CustomerRoles;
+(function (CustomerRoles) {
+    CustomerRoles["Admin"] = "admin";
+})(CustomerRoles || (exports.CustomerRoles = CustomerRoles = {}));

package/models/Evento/Player/types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventPlayerReason = exports.EventPlayerStatus = exports.EventPlayerRollCallVia = void 0;
+var EventPlayerRollCallVia;
+(function (EventPlayerRollCallVia) {
+    EventPlayerRollCallVia["QR"] = "QR";
+    EventPlayerRollCallVia["GeoLoc"] = "GeoLoc";
+    EventPlayerRollCallVia["Admin"] = "Admin";
+})(EventPlayerRollCallVia || (exports.EventPlayerRollCallVia = EventPlayerRollCallVia = {}));
+var EventPlayerStatus;
+(function (EventPlayerStatus) {
+    EventPlayerStatus["Confirmed"] = "confirmed";
+    EventPlayerStatus["Declined"] = "declined";
+})(EventPlayerStatus || (exports.EventPlayerStatus = EventPlayerStatus = {}));
+var EventPlayerReason;
+(function (EventPlayerReason) {
+    EventPlayerReason["Sick"] = "Sick";
+    EventPlayerReason["Vacation"] = "Vacation";
+    EventPlayerReason["ArrivingLate"] = "ArrivingLate";
+    EventPlayerReason["LeavingEarly"] = "LeavingEarly";
+    EventPlayerReason["Other"] = "Other";
+})(EventPlayerReason || (exports.EventPlayerReason = EventPlayerReason = {}));

package/models/Evento/Repertory/types.d.ts

@@ -0,0 +1,8 @@
+import { Timestamp } from '@google-cloud/firestore';
+import { SourceComposition, ThemeBasicData } from '../../Repertory/types';
+export interface EventRepertoryData extends ThemeBasicData {
+    order: number;
+    createdAt: Timestamp;
+    createdBy: string;
+    sourceComposition?: SourceComposition | null;
+}

package/models/Evento/index.d.ts

@@ -0,0 +1,94 @@
+import { DocumentReference } from '@google-cloud/firestore';
+import { InstrumentId } from '../../helpers/instruments';
+import { LanguagesTypes } from '../../lang';
+import { DocumentModel } from '../Model';
+import EventoPlayerBasic from './Player/basic';
+import { EventPlayerStatus } from './Player/types';
+import EventoPromoter from './promoter';
+import { AEventPlayerBasicData, EventData, EventResponseDeadlineOptions, EventStatusByTime } from './types';
+interface PlayerListOptions {
+    showAll?: boolean;
+    order?: InstrumentId[];
+    asObject?: boolean;
+}
+export default class Evento extends EventoPromoter<EventData> {
+    constructor(doc: DocumentModel, lang?: LanguagesTypes);
+    get maxAttendance(): number | null;
+    get isCapacityCompleted(): boolean;
+    get location(): FirebaseFirestore.GeoPoint | null;
+    get videoURL(): string | null;
+    get coverURL(): string | null;
+    get description(): string | null;
+    get descriptionSlate(): import("../../helpers/slate").Descendant[];
+    get owner(): DocumentReference;
+    get relEvents(): string[];
+    get isASerie(): boolean;
+    get playerIds(): string[];
+    get players(): Record<string, import("./types").EventPlayerBasicData>;
+    get playersCount(): number;
+    get repertory(): Record<string, import("./types").EventThemeBasicData>;
+    get repertoryIds(): string[];
+    get repertoryCount(): number;
+    get activeInvitationLink(): boolean;
+    getInvitationLink(landingHost: string): string;
+    getShortDynamicLink(landingHost: string): string;
+    get deletedAt(): FirebaseFirestore.Timestamp | null;
+    get deletedBy(): string | null;
+    get createdAt(): FirebaseFirestore.Timestamp;
+    get createdOn(): import("../../helpers/types").CreatedOn;
+    get rollCalledAt(): FirebaseFirestore.Timestamp | null;
+    get rollCalledBy(): string | null;
+    get rollCallReminderAt(): FirebaseFirestore.Timestamp | null;
+    get rollCallHistory(): import("./types").EventRollcallHistory[];
+    get notifyAt(): FirebaseFirestore.Timestamp;
+    get isActive(): boolean;
+    get isDeleted(): boolean;
+    get stage(): import("./types").EventStage | null;
+    get stageTemplateId(): string | null;
+    get statusByTime(): EventStatusByTime;
+    get repertoryList(): {
+        id: string;
+        order: number;
+        sourceComposition?: import("../Repertory/types").SourceComposition | null;
+        title: string;
+        compositor: string | null;
+        tags: string[];
+        media: import("../Repertory/types").ThemeMediaType | null;
+    }[];
+    playersList<T extends PlayerListOptions>(data?: T): T['asObject'] extends true ? AEventPlayerBasicData[] : EventoPlayerBasic[];
+    /** @deprecated use confirmedPlayers  */
+    get interestedPlayers(): EventoPlayerBasic[];
+    get confirmedPlayers(): EventoPlayerBasic[];
+    get declinedPlayers(): EventoPlayerBasic[];
+    get pendingPlayers(): EventoPlayerBasic[];
+    get confirmedRollCallPlayers(): EventoPlayerBasic[];
+    get declinedRollCallPlayers(): EventoPlayerBasic[];
+    get selectedPlayers(): EventoPlayerBasic[];
+    get discardedPlayers(): EventoPlayerBasic[];
+    get pendingSelectedPlayers(): EventoPlayerBasic[];
+    get isRollCalled(): boolean;
+    get templateId(): string | null;
+    get repeat(): import("./types").EventRepeatType | null;
+    isPlayer: (userId: string) => boolean;
+    getPlayer: (userId: string) => EventoPlayerBasic | null;
+    get responseDeadline(): {
+        option: EventResponseDeadlineOptions;
+        customAt: FirebaseFirestore.Timestamp | null;
+    };
+    get isSelectionMode(): boolean;
+    get selectionModeClosedAt(): FirebaseFirestore.Timestamp | null;
+    get isSelectionModeClosed(): boolean;
+    get isSelectionModeOpen(): boolean;
+    get sites(): boolean;
+    get imagesPath(): string[];
+    get attachmentsPath(): string[];
+    get questions(): {
+        confirmed: import("./types").EventQuestions[];
+        declined: import("./types").EventQuestions[];
+    };
+    getQuestionsByStatus(status: EventPlayerStatus): import("./types").EventQuestions[];
+    get reminders(): import("./types").EventReminderOptions[];
+    get payout(): import("./types").EventPayoutConfig | null;
+    get payoutRules(): import("../../types/payoutRule").EventoPayoutRuleEntry[];
+}
+export {};

package/models/Evento/index.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const externalUrls_1 = require("../../helpers/externalUrls");
+const orders_1 = require("../../helpers/instruments/orders");
+const orders_2 = require("../../helpers/musicStyles/orders");
+const lang_1 = require("../../lang");
+const basic_1 = __importDefault(require("./Player/basic"));
+const types_1 = require("./Player/types");
+const promoter_1 = __importDefault(require("./promoter"));
+const types_2 = require("./types");
+class Evento extends promoter_1.default {
+    constructor(doc, lang = lang_1.defaultLocale) {
+        super(doc, lang);
+        this.isPlayer = (userId) => {
+            return this.playerIds.includes(userId);
+        };
+        this.getPlayer = (userId) => {
+            return userId in this.players
+                ? new basic_1.default(this.id, { id: userId, ...this.players[userId] })
+                : null;
+        };
+    }
+    get maxAttendance() {
+        return this.data.maxAttendance;
+    }
+    get isCapacityCompleted() {
+        return (0, lodash_1.isNumber)(this.maxAttendance) && this.confirmedPlayers.length >= this.maxAttendance;
+    }
+    get location() {
+        return this.data.location;
+    }
+    get videoURL() {
+        return this.data.videoURL || null;
+    }
+    get coverURL() {
+        return this.data.coverURL || null;
+    }
+    get description() {
+        return this.data.description || null;
+    }
+    get descriptionSlate() {
+        return this.data.descriptionSlate || [];
+    }
+    get owner() {
+        return this.data.owner;
+    }
+    get relEvents() {
+        return this.data.relEvents || [];
+    }
+    get isASerie() {
+        return this.relEvents.length > 1;
+    }
+    get playerIds() {
+        return this.data.playerIds || [];
+    }
+    get players() {
+        return this.data.players || {};
+    }
+    get playersCount() {
+        return this.data.playerIds.length;
+    }
+    get repertory() {
+        return this.data.repertory || {};
+    }
+    get repertoryIds() {
+        return this.data.repertoryIds || [];
+    }
+    get repertoryCount() {
+        return this.repertoryIds.length;
+    }
+    get activeInvitationLink() {
+        return this.data.activeInvitationLink || false;
+    }
+    getInvitationLink(landingHost) {
+        const link = (0, externalUrls_1.buildEventInvitationUrl)(landingHost, this.id);
+        if (lang_1.LanguagesTypes.ES === this.lang) {
+            return link;
+        }
+        return `${link}?lang=${this.lang}`;
+    }
+    getShortDynamicLink(landingHost) {
+        const link = (0, externalUrls_1.buildEventUrl)(landingHost, this.id);
+        if (lang_1.LanguagesTypes.ES === this.lang) {
+            return link;
+        }
+        return `${link}?lang=${this.lang}`;
+    }
+    get deletedAt() {
+        return this.data.deletedAt;
+    }
+    get deletedBy() {
+        return this.data.deletedBy || null;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get createdOn() {
+        return this.data.createdOn;
+    }
+    get rollCalledAt() {
+        return this.data.rollCalledAt;
+    }
+    get rollCalledBy() {
+        return this.data.rollCalledBy || null;
+    }
+    get rollCallReminderAt() {
+        return this.data.rollCallReminderAt;
+    }
+    get rollCallHistory() {
+        return this.data.rollCallHistory || [];
+    }
+    get notifyAt() {
+        return this.data.notifyAt;
+    }
+    get isActive() {
+        return !this.isDeleted && !this.isOutDate;
+    }
+    get isDeleted() {
+        return !this.exists || !(0, lodash_1.isNull)(this.deletedAt);
+    }
+    get stage() {
+        return this.data.stage || null;
+    }
+    get stageTemplateId() {
+        return this.data.stageTemplateId || null;
+    }
+    get statusByTime() {
+        if (this.isOutDate) {
+            return types_2.EventStatusByTime.Past;
+        }
+        if (this.isHappening) {
+            return types_2.EventStatusByTime.Now;
+        }
+        return types_2.EventStatusByTime.Future;
+    }
+    get repertoryList() {
+        const repertory = Object.keys(this.repertory).map((themeId) => ({
+            ...this.repertory[themeId],
+            id: themeId,
+        }));
+        return (0, lodash_1.orderBy)(repertory, 'order', 'asc');
+    }
+    playersList({ showAll, order, asObject } = {}) {
+        const players = asObject
+            ? Object.entries(this.players).map(([id, player]) => ({
+                id,
+                ...player,
+            }))
+            : Object.entries(this.players).map(([id, player]) => new basic_1.default(this.id, { id, ...player }));
+        const orderedPlayers = order
+            ? (0, orders_1.orderByInstruments)(players, 'mainInstrument', order)
+            : (0, orders_2.orderByMusicStyle)(players, 'mainInstrument', this.promoterInfo.musicStyle);
+        if (showAll)
+            return orderedPlayers;
+        return orderedPlayers.filter((player) => player.selected !== false);
+    }
+    /** @deprecated use confirmedPlayers  */
+    get interestedPlayers() {
+        return this.playersList({ showAll: true }).filter((player) => player.isInterested);
+    }
+    get confirmedPlayers() {
+        return this.playersList().filter((player) => player.isConfirmed);
+    }
+    get declinedPlayers() {
+        return this.playersList().filter((player) => player.isDeclined);
+    }
+    get pendingPlayers() {
+        return this.playersList().filter((player) => player.isPending);
+    }
+    get confirmedRollCallPlayers() {
+        return this.playersList().filter((player) => player.isRollCallConfirmed);
+    }
+    get declinedRollCallPlayers() {
+        return this.playersList().filter((player) => player.isRollCallDeclined);
+    }
+    get selectedPlayers() {
+        return this.playersList().filter((player) => player.isSelected);
+    }
+    get discardedPlayers() {
+        return this.playersList().filter((player) => player.isDiscarded);
+    }
+    get pendingSelectedPlayers() {
+        return this.playersList().filter((player) => player.isPendingSelected);
+    }
+    get isRollCalled() {
+        return this.rollCalledAt !== null;
+    }
+    get templateId() {
+        return this.data.templateId || null;
+    }
+    get repeat() {
+        return this.data.repeat || null;
+    }
+    get responseDeadline() {
+        return (this.data.responseDeadline || {
+            option: types_2.EventResponseDeadlineOptions.BeforeEvent,
+            customAt: null,
+        });
+    }
+    get isSelectionMode() {
+        return !(0, lodash_1.isNull)(this.selectionMode);
+    }
+    get selectionModeClosedAt() {
+        return this.data.selectionModeClosedAt || null;
+    }
+    get isSelectionModeClosed() {
+        return (!(0, lodash_1.isNull)(this.selectionModeClosedAt) && this.selectionMode === types_2.EventSelectionMode.Closed);
+    }
+    get isSelectionModeOpen() {
+        return (0, lodash_1.isNull)(this.selectionModeClosedAt) && this.selectionMode === types_2.EventSelectionMode.Open;
+    }
+    get sites() {
+        return this.data.sites || false;
+    }
+    get imagesPath() {
+        return this.data.imagesPath || [];
+    }
+    get attachmentsPath() {
+        return this.data.attachmentsPath || [];
+    }
+    get questions() {
+        if (!this.data.questions) {
+            return {
+                [types_1.EventPlayerStatus.Confirmed]: [],
+                [types_1.EventPlayerStatus.Declined]: [],
+            };
+        }
+        const confirmedQuestions = types_1.EventPlayerStatus.Confirmed in this.data.questions
+            ? this.data.questions[types_1.EventPlayerStatus.Confirmed]
+            : [];
+        const declinedQuestions = types_1.EventPlayerStatus.Declined in this.data.questions
+            ? this.data.questions[types_1.EventPlayerStatus.Declined]
+            : [];
+        return {
+            [types_1.EventPlayerStatus.Confirmed]: confirmedQuestions,
+            [types_1.EventPlayerStatus.Declined]: declinedQuestions,
+        };
+    }
+    getQuestionsByStatus(status) {
+        return this.questions[status] || [];
+    }
+    get reminders() {
+        return this.data.reminders || [];
+    }
+    get payout() {
+        return this.data.payout || null;
+    }
+    get payoutRules() {
+        return this.data.payout?.rules || [];
+    }
+}
+exports.default = Evento;