@glissandoo/lib 1.114.1 → 1.115.0

package/models/supabase/Composer/Composition/index.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../../../lang");
+const Model_1 = __importDefault(require("../../Model"));
+const lodash_1 = require("lodash");
+const objects_1 = require("../../../../helpers/objects");
+const ts_extras_1 = require("../../../../helpers/ts-extras");
+class ComposerComposition extends Model_1.default {
+    constructor(data, lang = lang_1.defaultLocale) {
+        super(data, lang);
+    }
+    get id() {
+        return this.data.id;
+    }
+    get uploaderComposerId() {
+        return this.data.uploaderComposerId;
+    }
+    get uploaderComposerArtisticName() {
+        return this.data.uploaderComposerArtisticName;
+    }
+    get uploaderComposerRole() {
+        return this.data.uploaderComposerRole;
+    }
+    get isComposerExternal() {
+        return this.uploaderComposerRole !== 'COMPOSER';
+    }
+    get isArrangerExternal() {
+        return this.uploaderComposerRole !== 'ARRANGER';
+    }
+    get externalComposerName() {
+        return this.data.externalComposerName;
+    }
+    get composerName() {
+        return this.data.composerName;
+    }
+    get arrangerName() {
+        return this.data.arrangerName;
+    }
+    get publisher() {
+        return this.data.publisher;
+    }
+    get title() {
+        return this.data.title;
+    }
+    get subtitle() {
+        return this.data.subtitle;
+    }
+    get description() {
+        return this.data.description;
+    }
+    get catalogueNumber() {
+        return this.data.catalogueNumber;
+    }
+    get duration() {
+        return this.data.duration;
+    }
+    get difficulty() {
+        return this.data.difficulty;
+    }
+    get genresIds() {
+        return this.data.genresIds;
+    }
+    get stylesIds() {
+        return this.data.stylesIds;
+    }
+    get instrumentationIds() {
+        return this.data.instrumentationIds;
+    }
+    get highlightedParts() {
+        return this.data.highlightedParts || [];
+    }
+    get year() {
+        return this.data.year;
+    }
+    get century() {
+        return this.data.century;
+    }
+    get samples() {
+        return this.data.samples || {};
+    }
+    get pdfSamples() {
+        return (0, objects_1.filter)(this.samples, (_, file) => file.type === 'fromFilesPdf');
+    }
+    get uploadedSamples() {
+        return (0, objects_1.filter)(this.samples, (_, file) => file.type === 'uploadedPdf' || file.type === 'uploadedAudio');
+    }
+    get imageSamples() {
+        return (0, objects_1.filter)(this.samples, (_, file) => file.type === 'image');
+    }
+    get samplesList() {
+        const fromFiles = (0, objects_1.map)(this.pdfSamples, (sampleId, sampleValue) => [
+            sampleId,
+            {
+                ...sampleValue,
+                filesPages: (0, objects_1.map)(sampleValue.filesPages, (fileId, filesPagesValue) => [
+                    fileId,
+                    (0, lodash_1.chain)([...filesPagesValue])
+                        .sortBy(({ order }) => order)
+                        .map(({ page }) => page)
+                        .value(),
+                ]),
+            },
+        ]);
+        return (0, objects_1.orderedMapToArray)({
+            ...this.samples,
+            ...fromFiles,
+        });
+    }
+    get samplesIds() {
+        return this.samplesList.map(({ id }) => id);
+    }
+    get files() {
+        return this.data.files;
+    }
+    get fileList() {
+        return (0, objects_1.mapToArray)(this.files);
+    }
+    get sectionIds() {
+        return (0, lodash_1.uniq)(this.fileList.map((file) => Object.keys(file.sections)).flat());
+    }
+    get filesPath() {
+        return this.data.filesPath;
+    }
+    get filesPathList() {
+        return (0, ts_extras_1.objectEntries)(this.filesPath || {})
+            .map(([sectionId, files]) => (files || []).map((file) => ({
+            sectionId: sectionId,
+            ...file,
+        })))
+            .flat();
+    }
+    get products() {
+        return this.data.products || {};
+    }
+    get cover() {
+        return this.data.cover;
+    }
+    get isCoverFromFile() {
+        return this.cover?.type === 'fromFile';
+    }
+    get isCoverCustom() {
+        return this.cover?.type === 'custom';
+    }
+    get visibility() {
+        return this.data.visibility;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get updatedAt() {
+        return this.data.updatedAt;
+    }
+    get deletedAt() {
+        return this.data.deletedAt;
+    }
+    get isActive() {
+        return !this.deletedAt;
+    }
+    get isDeleted() {
+        return !(0, lodash_1.isNull)(this.deletedAt);
+    }
+}
+exports.default = ComposerComposition;

package/models/supabase/Composer/Composition/types.d.ts

@@ -0,0 +1,96 @@
+import { Ordered } from '../../../../helpers/objects';
+import { DefaultInstrumentId } from '../../../../helpers/instruments';
+import { IsRelationName, Tables, TablesInsert, TablesUpdate } from '../../../../types/supabase';
+import { BaseRepertoireFile, RepertoireFileId } from '../../../Repertory/types';
+interface ComposerCompositionBaseCover {
+    url: string;
+    type: 'fromFile' | 'custom' | 'generated';
+}
+export interface ComposerCompositionFromFileCover extends ComposerCompositionBaseCover {
+    type: 'fromFile';
+    filePage: {
+        fileId: string;
+        page: number;
+    };
+}
+export interface ComposerCompositionCustomCover extends ComposerCompositionBaseCover {
+    type: 'custom';
+}
+export interface ComposerCompositionGeneratedCover extends ComposerCompositionBaseCover {
+    type: 'generated';
+    bgColor?: string;
+}
+export type ComposerCompositionCover = ComposerCompositionFromFileCover | ComposerCompositionCustomCover | ComposerCompositionGeneratedCover;
+export interface ComposerCompositionFromFilesPdfSamplePage extends Ordered {
+    page: number;
+}
+export type ComposerCompositionFromFilesPdfSampleFilesPages = Record<RepertoireFileId, ComposerCompositionFromFilesPdfSamplePage[]>;
+interface ComposerCompositionBaseSample extends Ordered {
+    type: 'fromFilesPdf' | 'uploadedPdf' | 'uploadedAudio' | 'youtube' | 'image';
+    customName: string;
+}
+export interface ComposerCompositionFromFilesPdfSample extends ComposerCompositionBaseSample {
+    type: 'fromFilesPdf';
+    filesPages: ComposerCompositionFromFilesPdfSampleFilesPages;
+    path: string;
+}
+export interface ComposerCompositionUploadedPdfSample extends ComposerCompositionBaseSample, BaseRepertoireFile {
+    type: 'uploadedPdf';
+    watermark?: boolean;
+    /** Path to the original raw upload (no watermark). Used to regenerate the processed file. */
+    originalPath?: string;
+}
+export interface ComposerCompositionUploadedAudioSample extends ComposerCompositionBaseSample, BaseRepertoireFile {
+    type: 'uploadedAudio';
+    /** Path to the original raw upload. Used to regenerate the processed file when customName changes. */
+    originalPath?: string;
+}
+export interface ComposerCompositionYoutubeSample extends ComposerCompositionBaseSample {
+    type: 'youtube';
+    videoId: string;
+    videoTitle?: string;
+    videoDescription?: string;
+    videoThumbnails?: Record<string, {
+        url: string;
+        width: string;
+        height: string;
+    }>;
+}
+export interface ComposerCompositionImageSample extends ComposerCompositionBaseSample {
+    type: 'image';
+    /** Source PDF file ID (for provenance tracking) */
+    fileId: string;
+    /** Source PDF page number */
+    page: number;
+    /** Storage path to rendered JPEG */
+    path: string;
+}
+export type ComposerCompositionSample = ComposerCompositionFromFilesPdfSample | ComposerCompositionUploadedPdfSample | ComposerCompositionUploadedAudioSample | ComposerCompositionYoutubeSample | ComposerCompositionImageSample;
+export type ComposerCompositionProductType = 'Score' | 'Parts' | 'ScoreAndParts';
+export declare const composerCompositionProductTypes: ComposerCompositionProductType[];
+export declare const isComposerCompositionProductType: (value: string) => value is ComposerCompositionProductType;
+export interface ComposerCompositionProductConfig {
+    price: number;
+    currency: string;
+    basePrice?: number;
+    baseCurrency?: string;
+    stripeProductId?: string;
+    stripePriceId?: string;
+    recurring?: {
+        interval: 'day' | 'month' | 'week' | 'year';
+        intervalCount: number;
+    };
+}
+export type ComposerCompositionProducts = Partial<Record<ComposerCompositionProductType, ComposerCompositionProductConfig>>;
+export declare const getComposerCompositionProducts: (value: unknown) => ComposerCompositionProducts;
+export interface ComposerCompositionHighlightedPart {
+    partId: DefaultInstrumentId;
+    quantity: number;
+    soloist: boolean;
+    offstage: boolean;
+}
+type tableName = IsRelationName<'composerComposition'>;
+export type ComposerCompositionInsertData = TablesInsert<`${tableName}`>;
+export type ComposerCompositionUpdateData = TablesUpdate<`${tableName}`>;
+export type ComposerCompositionModelData = Tables<`${tableName}Model`>;
+export {};

package/models/supabase/Composer/Composition/types.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComposerCompositionProducts = exports.isComposerCompositionProductType = exports.composerCompositionProductTypes = void 0;
+exports.composerCompositionProductTypes = [
+    'Score',
+    'Parts',
+    'ScoreAndParts',
+];
+const isComposerCompositionProductType = (value) => exports.composerCompositionProductTypes.includes(value);
+exports.isComposerCompositionProductType = isComposerCompositionProductType;
+const isComposerCompositionProductConfig = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const product = value;
+    return (typeof product.price === 'number' &&
+        typeof product.currency === 'string' &&
+        (product.basePrice === undefined || typeof product.basePrice === 'number') &&
+        (product.baseCurrency === undefined || typeof product.baseCurrency === 'string') &&
+        (product.stripeProductId === undefined || typeof product.stripeProductId === 'string') &&
+        (product.stripePriceId === undefined || typeof product.stripePriceId === 'string'));
+};
+const getComposerCompositionProducts = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.entries(value).reduce((acc, [type, config]) => {
+        if ((0, exports.isComposerCompositionProductType)(type) && isComposerCompositionProductConfig(config)) {
+            acc[type] = config;
+        }
+        return acc;
+    }, {});
+};
+exports.getComposerCompositionProducts = getComposerCompositionProducts;

package/models/supabase/Composer/Notification/index.d.ts

@@ -0,0 +1,4 @@
+import ModelFromSupabaseWithLang from '../../Model';
+import { ComposerNotificationModelData } from './types';
+export default class ComposerNotification extends ModelFromSupabaseWithLang<ComposerNotificationModelData> {
+}

package/models/supabase/Composer/Notification/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Model_1 = __importDefault(require("../../Model"));
+class ComposerNotification extends Model_1.default {
+}
+exports.default = ComposerNotification;

package/models/supabase/Composer/Notification/types.d.ts

@@ -0,0 +1,39 @@
+import { IsRelationName, Tables, TablesInsert, TablesUpdate } from '../../../../types/supabase';
+export declare enum ComposerNotificationType {
+    SaleCreated = "sale.created",
+    SaleUpgraded = "sale.upgraded",
+    SaleRefunded = "sale.refunded",
+    PayoutRequested = "payout.requested",
+    PayoutCompleted = "payout.completed",
+    PayoutCancelled = "payout.cancelled",
+    PayoutFailed = "payout.failed",
+    PerformanceCreated = "performance.created",
+    PerformanceUpdated = "performance.updated",
+    PerformanceRemoved = "performance.removed",
+    PerformanceCancelled = "performance.cancelled",
+    PerformanceUpcomingReminder = "performance.upcomingReminder",
+    SummaryWeekly = "summary.weekly",
+    MilestoneReached = "milestone.reached"
+}
+export declare enum ComposerNotificationEmailStatus {
+    Skipped = "skipped",
+    Pending = "pending",
+    Sent = "sent",
+    Failed = "failed"
+}
+export type ComposerNotificationParamValue = string | number | boolean | null;
+export type ComposerNotificationParams = Record<string, ComposerNotificationParamValue>;
+export type ComposerNotificationMetadataValue = ComposerNotificationParamValue | ComposerNotificationMetadataValue[] | {
+    [key: string]: ComposerNotificationMetadataValue;
+};
+export type ComposerNotificationMetadata = Record<string, ComposerNotificationMetadataValue>;
+type tableName = IsRelationName<'composerNotification'>;
+type settingTableName = IsRelationName<'composerNotificationSetting'>;
+export type ComposerNotificationModelData = Tables<tableName>;
+export type ComposerNotificationInsertData = TablesInsert<tableName>;
+export type ComposerNotificationUpdateData = TablesUpdate<tableName>;
+export type ComposerNotificationSettingData = Tables<settingTableName>;
+export type ComposerNotificationSettingInsertData = TablesInsert<settingTableName>;
+export type ComposerNotificationSettingUpdateData = TablesUpdate<settingTableName>;
+export type ComposerNotificationSettingEditable = Pick<ComposerNotificationSettingData, 'salesDashboard' | 'salesEmail' | 'payoutsDashboard' | 'payoutsEmail' | 'performancesDashboard' | 'performancesEmail' | 'summariesDashboard' | 'summariesEmail'>;
+export {};

package/models/supabase/Composer/Notification/types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComposerNotificationEmailStatus = exports.ComposerNotificationType = void 0;
+var ComposerNotificationType;
+(function (ComposerNotificationType) {
+    ComposerNotificationType["SaleCreated"] = "sale.created";
+    ComposerNotificationType["SaleUpgraded"] = "sale.upgraded";
+    ComposerNotificationType["SaleRefunded"] = "sale.refunded";
+    ComposerNotificationType["PayoutRequested"] = "payout.requested";
+    ComposerNotificationType["PayoutCompleted"] = "payout.completed";
+    ComposerNotificationType["PayoutCancelled"] = "payout.cancelled";
+    ComposerNotificationType["PayoutFailed"] = "payout.failed";
+    ComposerNotificationType["PerformanceCreated"] = "performance.created";
+    ComposerNotificationType["PerformanceUpdated"] = "performance.updated";
+    ComposerNotificationType["PerformanceRemoved"] = "performance.removed";
+    ComposerNotificationType["PerformanceCancelled"] = "performance.cancelled";
+    ComposerNotificationType["PerformanceUpcomingReminder"] = "performance.upcomingReminder";
+    ComposerNotificationType["SummaryWeekly"] = "summary.weekly";
+    ComposerNotificationType["MilestoneReached"] = "milestone.reached";
+})(ComposerNotificationType || (exports.ComposerNotificationType = ComposerNotificationType = {}));
+var ComposerNotificationEmailStatus;
+(function (ComposerNotificationEmailStatus) {
+    ComposerNotificationEmailStatus["Skipped"] = "skipped";
+    ComposerNotificationEmailStatus["Pending"] = "pending";
+    ComposerNotificationEmailStatus["Sent"] = "sent";
+    ComposerNotificationEmailStatus["Failed"] = "failed";
+})(ComposerNotificationEmailStatus || (exports.ComposerNotificationEmailStatus = ComposerNotificationEmailStatus = {}));

package/models/supabase/Composer/Payout/index.d.ts

@@ -0,0 +1,4 @@
+import ModelFromSupabaseWithLang from '../../Model';
+import { ComposerPayoutModelData } from './types';
+export default class ComposerPayout extends ModelFromSupabaseWithLang<ComposerPayoutModelData> {
+}

package/models/supabase/Composer/Payout/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Model_1 = __importDefault(require("../../Model"));
+class ComposerPayout extends Model_1.default {
+}
+exports.default = ComposerPayout;

package/models/supabase/Composer/Payout/status.d.ts

@@ -0,0 +1 @@
+export type ComposerPayoutStatus = 'pending' | 'completed' | 'cancelled' | 'failed';

package/models/supabase/Composer/Payout/types.d.ts

@@ -0,0 +1,5 @@
+import { Tables, TablesInsert, TablesUpdate } from '../../../../types/supabase';
+export type { ComposerPayoutStatus } from './status';
+export type ComposerPayoutModelData = Tables<'composerPayout'>;
+export type ComposerPayoutInsertData = TablesInsert<'composerPayout'>;
+export type ComposerPayoutUpdateData = TablesUpdate<'composerPayout'>;

package/models/supabase/Composer/PerformanceAttendance/types.d.ts

@@ -0,0 +1,4 @@
+import { Tables, TablesInsert, TablesUpdate } from '../../../../types/supabase';
+export type ComposerPerformanceAttendanceModelData = Tables<'composerPerformanceAttendance'>;
+export type ComposerPerformanceAttendanceInsertData = TablesInsert<'composerPerformanceAttendance'>;
+export type ComposerPerformanceAttendanceUpdateData = TablesUpdate<'composerPerformanceAttendance'>;

package/models/supabase/Composer/index.d.ts

@@ -0,0 +1,78 @@
+import { LanguagesTypes } from '../../../lang';
+import ModelFromSupabaseWithLang from '../Model';
+import { ComposerModelData } from './types';
+import { CustomInstrument, CustomInstrumentId, InstrumentsRecord } from '../../../helpers/instruments';
+import { SocialNetwork } from '../../../helpers/types';
+export default class Composer extends ModelFromSupabaseWithLang<ComposerModelData> {
+    constructor(data: ComposerModelData, lang?: LanguagesTypes);
+    get isActive(): boolean;
+    get isDeleted(): boolean;
+    get artisticEmail(): string | null;
+    get artisticName(): string;
+    get visibility(): boolean;
+    get country(): string | null;
+    get currency(): string | null;
+    get createdAt(): string;
+    get deletedAt(): string | null;
+    get description(): import("../../../helpers/slate").Descendant[] | null;
+    get id(): string;
+    get locality(): string | null;
+    get location(): {
+        longitude: number | null;
+        latitude: number | null;
+    } | {
+        longitude: number | null;
+        latitude: number | null;
+    } | null;
+    get photoURL(): string;
+    get updatedAt(): string;
+    get userId(): string;
+    get username(): string;
+    get instruments(): InstrumentsRecord;
+    get instrumentsList(): Pick<(import("../../../helpers/objects").Ordered & {
+        id: import("../../../helpers/instruments").DefaultInstrumentId | `customInstrument-${string}`;
+    }) | (CustomInstrument & {
+        id: import("../../../helpers/instruments").DefaultInstrumentId | `customInstrument-${string}`;
+    }), "id">[];
+    get instrumentsIds(): (import("../../../helpers/instruments").DefaultInstrumentId | `customInstrument-${string}`)[];
+    get customInstruments(): Record<CustomInstrumentId, CustomInstrument>;
+    get customInstrumentsList(): Pick<CustomInstrument & {
+        id: `customInstrument-${string}`;
+    }, "id" | "icon" | "name" | "basedOnInstrument">[];
+    get customInstrumentsIds(): `customInstrument-${string}`[];
+    get repertoireTags(): {
+        [x: string]: {
+            title: string;
+            default: boolean;
+        };
+    } | {
+        [x: string]: {
+            title: string;
+            default: boolean;
+        };
+    };
+    get repertoireTagsList(): ({
+        title: string;
+        default: boolean;
+    } & {
+        id: string;
+    })[];
+    getRepertoireTagName(id: string): string | null;
+    get socialNetworks(): {
+        facebook: string | null;
+        twitter: string | null;
+        instagram: string | null;
+        youtube: string | null;
+        web: string | null;
+    } | {
+        [x: string]: string | number | boolean | import("../../../types/supabase").Json[] | {
+            [x: string]: string | number | boolean | import("../../../types/supabase").Json[] | /*elided*/ any | null | undefined;
+        } | null | undefined;
+        facebook: string | null;
+        twitter: string | null;
+        instagram: string | null;
+        youtube: string | null;
+        web: string | null;
+    };
+    getSocialNetworkUrl(id: SocialNetwork): string | null;
+}

package/models/supabase/Composer/index.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../../lang");
+const Model_1 = __importDefault(require("../Model"));
+const objects_1 = require("../../../helpers/objects");
+const lodash_1 = require("lodash");
+class Composer extends Model_1.default {
+    constructor(data, lang = lang_1.defaultLocale) {
+        super(data, lang);
+    }
+    get isActive() {
+        return !this.deletedAt;
+    }
+    get isDeleted() {
+        return !(0, lodash_1.isNull)(this.deletedAt);
+    }
+    get artisticEmail() {
+        return this.data.artisticEmail;
+    }
+    get artisticName() {
+        return this.data.artisticName;
+    }
+    get visibility() {
+        return this.data.visibility;
+    }
+    get country() {
+        return this.data.country;
+    }
+    get currency() {
+        return this.data.currency;
+    }
+    get createdAt() {
+        return this.data.createdAt;
+    }
+    get deletedAt() {
+        return this.data.deletedAt;
+    }
+    get description() {
+        return this.data.description;
+    }
+    get id() {
+        return this.data.id;
+    }
+    get locality() {
+        return this.data.locality;
+    }
+    get location() {
+        return this.data.location;
+    }
+    get photoURL() {
+        return this.data.photoURL;
+    }
+    get updatedAt() {
+        return this.data.updatedAt;
+    }
+    get userId() {
+        return this.data.userId;
+    }
+    get username() {
+        return this.data.username;
+    }
+    get instruments() {
+        return this.data.instruments;
+    }
+    get instrumentsList() {
+        return (0, objects_1.orderedMapToArray)(this.instruments);
+    }
+    get instrumentsIds() {
+        return this.instrumentsList.map(({ id }) => id);
+    }
+    get customInstruments() {
+        return Object.fromEntries(Object.entries(this.instruments).filter(([key]) => key.startsWith('customInstrument-')));
+    }
+    get customInstrumentsList() {
+        return (0, objects_1.orderedMapToArray)(this.customInstruments);
+    }
+    get customInstrumentsIds() {
+        return this.customInstrumentsList.map(({ id }) => id);
+    }
+    get repertoireTags() {
+        return this.data.repertoireTags;
+    }
+    get repertoireTagsList() {
+        return (0, objects_1.mapToArray)(this.repertoireTags);
+    }
+    getRepertoireTagName(id) {
+        if (!(id in this.repertoireTags))
+            return null;
+        const tag = this.repertoireTags[id];
+        return tag.default ? (0, lang_1.getTranslation)(tag.title, this.lang) : tag.title;
+    }
+    get socialNetworks() {
+        return this.data.socialNetworks;
+    }
+    getSocialNetworkUrl(id) {
+        if (id in this.socialNetworks) {
+            return this.socialNetworks[id];
+        }
+        return null;
+    }
+}
+exports.default = Composer;

package/models/supabase/Composer/types.d.ts

@@ -0,0 +1,6 @@
+import { IsRelationName, Tables, TablesInsert, TablesUpdate } from '../../../types/supabase';
+type tableName = IsRelationName<'composer'>;
+export type ComposerInsertData = TablesInsert<`${tableName}`>;
+export type ComposerUpdateData = TablesUpdate<`${tableName}`>;
+export type ComposerModelData = Tables<`${tableName}Model`>;
+export {};

package/models/supabase/Composer/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/models/supabase/EventHistory/index.d.ts

@@ -0,0 +1,22 @@
+import { LanguagesTypes } from '../../../lang';
+import ModelFromSupabaseWithLang from '../Model';
+import { EventHistoryModelData } from './types';
+export default class EventHistory extends ModelFromSupabaseWithLang<EventHistoryModelData> {
+    constructor(data: EventHistoryModelData, lang?: LanguagesTypes);
+    get id(): number;
+    get action(): import("./types").EventHistoryAction;
+    get value(): {
+        [x: string]: unknown;
+    } | {
+        [x: string]: unknown;
+    } | null;
+    get prevValue(): {
+        [x: string]: unknown;
+    } | {
+        [x: string]: unknown;
+    } | null;
+    get createdAt(): string;
+    get eventId(): string;
+    get groupId(): string;
+    get userId(): string;
+}

package/models/supabase/EventHistory/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lang_1 = require("../../../lang");
+const Model_1 = __importDefault(require("../Model"));
+class EventHistory extends Model_1.default {
+    constructor(data, lang = lang_1.defaultLocale) {
+        super(data, lang);
+    }
+    get id() {
+        return this.data.id;
+    }
+    get action() {
+        return this.data.action;
+    }
+    get value() {
+        return this.data.value;
+    }
+    get prevValue() {
+        return this.data.prev_value;
+    }
+    get createdAt() {
+        return this.data.created_at;
+    }
+    get eventId() {
+        return this.data.event_id;
+    }
+    get groupId() {
+        return this.data.group_id;
+    }
+    get userId() {
+        return this.data.user_id;
+    }
+}
+exports.default = EventHistory;