@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Profile.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Profile = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const Operation_1 = require("../markup/Operation");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Time_1 = require("./Time");
+class Profile extends Content_1.Content {
+    static makeProfileId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.PROFILE);
+    }
+    static create(userId) {
+        const now = Time_1.MultiClock.now();
+        const profileId = Profile.makeProfileId(userId);
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: profileId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.PROFILE,
+                id: profileId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                username: null,
+                full_name: '',
+                avatar_media_ref: null,
+                avatar_cropping: null
+            }
+        });
+    }
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("Profile.payload");
+        return this.doc.data.payload;
+    }
+    get username() {
+        this.checkDisposed("Profile.username");
+        return this.payload.username;
+    }
+    setUsername(value) {
+        this.checkDisposed("Profile.setUsername");
+        if (this.username != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'username'], value);
+            batch.commit();
+        }
+    }
+    get fullName() {
+        this.checkDisposed("Profile.fullName");
+        return this.payload.full_name;
+    }
+    setFullName(value) {
+        this.checkDisposed("Profile.setFullName");
+        if (this.fullName !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'full_name'], value);
+            batch.commit();
+        }
+    }
+    get avatarMediaRef() {
+        this.checkDisposed("Profile.avatarMediaRef");
+        return this.payload.avatar_media_ref;
+    }
+    setAvatarMediaRef(value) {
+        this.checkDisposed("Profile.setAvatarMediaRef");
+        if (this.avatarMediaRef !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'avatar_media_ref'], value);
+            batch.commit();
+        }
+    }
+    get avatarCropping() {
+        this.checkDisposed("Profile.avatarCropping");
+        return this.payload.avatar_cropping;
+    }
+    setAvatarCropping(value) {
+        this.checkDisposed("Profile.setAvatarCropping");
+        if (this.avatarCropping !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'avatar_cropping'], value);
+            batch.commit();
+        }
+    }
+    static async findByUsername(username) {
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        return shareSync.findAndAcquire(ContentKind_1.ContentKind.PROFILE, { "payload.username": username });
+    }
+}
+exports.Profile = Profile;

package/dist/models/content/RichText.d.ts

@@ -0,0 +1,58 @@
+/// <reference path="../../../decs.d.ts" />
+import { Op as DeltaOp } from "@shaxpir/quill-delta";
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Checkpointable } from './Checkpointable';
+import { ContentId, ContentMeta } from "./Content";
+import { MultiTime } from './Time';
+export interface FormatAttr {
+    align?: string;
+    blockquote?: boolean;
+    bold?: boolean;
+    comment?: ContentId[];
+    header?: number;
+    highlight?: any[];
+    indent?: number;
+    italic?: boolean;
+    link?: string;
+    list?: "ordered" | "bullet";
+    script: "sub" | "super";
+    strike?: boolean;
+    underline?: boolean;
+}
+export interface FormatEmbed {
+    divider?: boolean;
+}
+export interface Format {
+    at: number;
+    len: number;
+    attr?: FormatAttr;
+    embed?: FormatEmbed;
+}
+export declare enum RichTextFlavor {
+    quill = "quill"
+}
+export interface QuillDoc {
+    ops: DeltaOp[];
+}
+export interface RichTextPayload {
+    richtext_flavor: RichTextFlavor;
+    richtext_body: QuillDoc;
+    word_count: number;
+}
+export interface RichTextBody {
+    meta: ContentMeta;
+    payload: RichTextPayload;
+}
+export declare abstract class RichText extends Checkpointable {
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): RichTextPayload;
+    get richtextFlavor(): RichTextFlavor;
+    get richtextBody(): QuillDoc;
+    get wordCount(): number;
+    setWordCount(value: number): void;
+    get mediaIds(): ContentId[];
+    get commentIds(): ContentId[];
+    updateRichText(deltaOps: DeltaOp[], newWordCount: number): void;
+    beforeRestoreTo(checkpoint: Checkpointable, now: MultiTime): Promise<void>;
+}

package/dist/models/content/RichText.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RichText = exports.RichTextFlavor = void 0;
+const util_1 = require("../../util");
+const markup_1 = require("../markup");
+const BodyFormat_1 = require("../markup/BodyFormat");
+const Checkpointable_1 = require("./Checkpointable");
+const ContentKind_1 = require("./ContentKind");
+var RichTextFlavor;
+(function (RichTextFlavor) {
+    RichTextFlavor["quill"] = "quill";
+})(RichTextFlavor || (exports.RichTextFlavor = RichTextFlavor = {}));
+class RichText extends Checkpointable_1.Checkpointable {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("RichText.payload");
+        return this.doc.data.payload;
+    }
+    get richtextFlavor() {
+        this.checkDisposed("RichText.richtextFlavor");
+        return this.payload.richtext_flavor;
+    }
+    get richtextBody() {
+        this.checkDisposed("RichText.richtextBody");
+        return this.payload.richtext_body;
+    }
+    get wordCount() {
+        this.checkDisposed("RichText.wordCount");
+        return this.payload.word_count;
+    }
+    setWordCount(value) {
+        this.checkDisposed("RichText.setWordCount");
+        if (this.wordCount !== value) {
+            const batch = new markup_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'word_count'], value);
+            batch.commit();
+        }
+    }
+    get mediaIds() {
+        this.checkDisposed("RichText.mediaIds");
+        return BodyFormat_1.BodyFormatModel.getMediaIdsFromDeltaOps(this.richtextBody.ops);
+    }
+    get commentIds() {
+        this.checkDisposed("RichText.commentIds");
+        return BodyFormat_1.BodyFormatModel.getCommentIdsFromDeltaOps(this.richtextBody.ops);
+    }
+    updateRichText(deltaOps, newWordCount) {
+        this.checkDisposed("RichText.updateRichText");
+        const batch = new markup_1.BatchOperation(this);
+        batch.applyRichText(['payload', 'richtext_body'], deltaOps);
+        if (this.wordCount != newWordCount) {
+            batch.setPathValue(['payload', 'word_count'], newWordCount);
+        }
+        batch.commit();
+    }
+    async beforeRestoreTo(checkpoint, now) {
+        this.checkDisposed("RichText.beforeRestoreTo");
+        // Restore all embedded comments
+        const checkpointTimestamp = checkpoint.createdAt.utc_time;
+        const commentIds = this.commentIds;
+        if (commentIds.length > 0) {
+            for (let i = 0; i < commentIds.length; i++) {
+                const commentId = commentIds[i];
+                const commentHead = await this.shareSync.acquire(ContentKind_1.ContentKind.COMMENT, commentId);
+                const commentCheckpoint = await commentHead.acquireLatestCheckpointAt(checkpointTimestamp);
+                // If the HEAD comment is already the most recent checkpoint, or if the payload hasn't
+                // changed since that checkpoint was taken, then there's no need to restore this comment.
+                if (!commentCheckpoint.isHead && !util_1.Struct.equals(commentHead.payload, commentCheckpoint.payload)) {
+                    await commentHead.restoreTo(commentCheckpoint, now);
+                }
+                commentCheckpoint.release();
+                commentHead.release();
+            }
+        }
+    }
+}
+exports.RichText = RichText;

package/dist/models/content/Session.d.ts

@@ -0,0 +1,39 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from "../../repo/ShareSync";
+import { Activity } from "./Activity";
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { Environment } from "./Environment";
+import { MultiTime } from "./Time";
+export interface SessionPayload {
+    start: MultiTime;
+    end: MultiTime;
+    tz_offset: number;
+    device_id: ContentId;
+    duration_minutes: number;
+    environment: Environment;
+    word_count: number;
+    activity: Activity[];
+}
+export interface SessionBody extends ContentBody {
+    meta: ContentMeta;
+    payload: SessionPayload;
+}
+export declare class Session extends Content {
+    static makeSessionId(userId: ContentId): ContentId;
+    static create(userId: ContentId, deviceId: ContentId, environment: Environment): Session;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): SessionPayload;
+    touch(): void;
+    get start(): MultiTime;
+    get end(): MultiTime;
+    get tzOffset(): number;
+    get durationMinutes(): number;
+    get deviceId(): ContentId;
+    get environment(): Environment;
+    get wordCount(): number;
+    setWordCount(value: number): void;
+    get activity(): Activity[];
+    recordActivity(newActivity: Activity): void;
+    modelUpdated(): Promise<void>;
+}

package/dist/models/content/Session.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const Struct_1 = require("../../util/Struct");
+const Operation_1 = require("../markup/Operation");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Metric_1 = require("./Metric");
+const Time_1 = require("./Time");
+const Workspace_1 = require("./Workspace");
+class Session extends Content_1.Content {
+    static makeSessionId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.SESSION);
+    }
+    static create(userId, deviceId, environment) {
+        let now = Time_1.MultiClock.now();
+        let sessionId = Session.makeSessionId(userId);
+        let sessionRef = Content_1.Content.makeContentRef(sessionId, now.utc_time);
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: sessionRef,
+                is_head: false,
+                kind: ContentKind_1.ContentKind.SESSION,
+                id: sessionId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                start: now,
+                end: now,
+                tz_offset: (new Date()).getTimezoneOffset(),
+                duration_minutes: 0,
+                device_id: deviceId,
+                environment: environment,
+                word_count: 0,
+                activity: []
+            }
+        });
+    }
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("Session.payload");
+        return this.doc.data.payload;
+    }
+    touch() {
+        this.checkDisposed("Session.touch");
+        const batch = new Operation_1.BatchOperation(this);
+        let nowUtc = batch.at.utc_time;
+        let nowLocal = batch.at.local_time;
+        let minutes = Time_1.Time.absDiffMinutes(nowUtc, this.start.utc_time);
+        batch.setPathValue(['payload', 'duration_minutes'], minutes);
+        batch.setPathValue(['payload', 'end', 'utc_time'], nowUtc);
+        batch.setPathValue(['payload', 'end', 'local_time'], nowLocal);
+        batch.commit();
+    }
+    get start() {
+        this.checkDisposed("Session.start");
+        return this.payload.start;
+    }
+    get end() {
+        this.checkDisposed("Session.end");
+        return this.payload.end;
+    }
+    get tzOffset() {
+        this.checkDisposed("Session.tzOffset");
+        return this.payload.tz_offset;
+    }
+    get durationMinutes() {
+        this.checkDisposed("Session.durationMinutes");
+        return this.payload.duration_minutes;
+    }
+    get deviceId() {
+        this.checkDisposed("Session.deviceId");
+        return this.payload.device_id;
+    }
+    get environment() {
+        this.checkDisposed("Session.environment");
+        return this.payload.environment;
+    }
+    get wordCount() {
+        this.checkDisposed("Session.wordCount");
+        return this.payload.word_count;
+    }
+    setWordCount(value) {
+        this.checkDisposed("Session.setWordCount");
+        if (this.wordCount !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'word_count'], value);
+            batch.commit();
+        }
+    }
+    get activity() {
+        this.checkDisposed("Session.activity");
+        return this.payload.activity;
+    }
+    recordActivity(newActivity) {
+        this.checkDisposed("Session.recordActivity");
+        // TODO: instead of rebuilding the activity list completely on every change,
+        // update only the deeply-nested fields within the Activity array.
+        let newActivities = [];
+        let replaced = false;
+        // Iterate through the activities in the session, replacing any existing activities with new ones (having
+        // updated word-counts and timestamps) and summing them all up to produce the session-total-word-count.
+        let sessionWordCount = 0;
+        let existingActivities = this.payload.activity;
+        for (let i = 0, len = existingActivities.length; i < len; i++) {
+            let existingActivity = existingActivities[i];
+            if (existingActivity.id === newActivity.id) {
+                if (newActivity.hasOwnProperty("word_count")) {
+                    sessionWordCount += newActivity.word_count;
+                }
+                newActivities.push(newActivity);
+                replaced = true;
+            }
+            else {
+                newActivities.push(existingActivity);
+                if (existingActivity.hasOwnProperty("word_count")) {
+                    sessionWordCount += existingActivity.word_count;
+                }
+            }
+        }
+        if (replaced === false) {
+            newActivities.push(newActivity);
+            if (newActivity.hasOwnProperty("word_count")) {
+                sessionWordCount += newActivity.word_count;
+            }
+        }
+        const now = Time_1.MultiClock.now();
+        const batch = new Operation_1.BatchOperation(this, now);
+        batch.setPathValue(['payload', 'end'], now);
+        if (this.wordCount !== sessionWordCount) {
+            batch.setPathValue(['payload', 'word_count'], sessionWordCount);
+        }
+        if (!Struct_1.Struct.equals(existingActivities, newActivities)) {
+            batch.setPathValue(['payload', 'activity'], newActivities);
+        }
+        batch.commit();
+    }
+    async modelUpdated() {
+        this.checkDisposed("Session.modelUpdated");
+        await super.modelUpdated();
+        const shareSync = this.shareSync;
+        const sessionId = this.id;
+        const userId = this.owner;
+        const date = Time_1.Time.dateFrom(this.createdAt.local_time);
+        const workspaceId = Workspace_1.Workspace.makeWorkspaceId(userId);
+        const workspace = await this.shareSync.acquire(ContentKind_1.ContentKind.WORKSPACE, workspaceId);
+        const sessionsOnDate = await workspace.acquireSessionsFromDate(sessionId, date);
+        workspace.release();
+        let wordCountOnDate = 0;
+        let minutesWritingOnDate = 0;
+        for (let i = 0, len = sessionsOnDate.length; i < len; i++) {
+            const sessionOnDate = sessionsOnDate[i];
+            wordCountOnDate += sessionOnDate.wordCount;
+            minutesWritingOnDate += sessionOnDate.durationMinutes;
+            sessionOnDate.release();
+        }
+        const wordCountMetricId = Metric_1.Metric.makeMetricId(userId, Metric_1.MetricName.WORD_COUNT);
+        const wordCountMetric = await shareSync.acquire(ContentKind_1.ContentKind.METRIC, wordCountMetricId);
+        wordCountMetric.setDateAmount(date, wordCountOnDate);
+        wordCountMetric.release();
+        const minutesWritingMetricId = Metric_1.Metric.makeMetricId(userId, Metric_1.MetricName.MINUTES_WRITING);
+        const minutesWritingMetric = await shareSync.acquire(ContentKind_1.ContentKind.METRIC, minutesWritingMetricId);
+        minutesWritingMetric.setDateAmount(date, minutesWritingOnDate);
+        minutesWritingMetric.release();
+    }
+}
+exports.Session = Session;

package/dist/models/content/Speech.d.ts

@@ -0,0 +1,67 @@
+export declare enum SpeechDataType {
+    AUDIO_MP3 = "audio_mp3",
+    AUDIO_OGG = "audio_ogg",
+    META_WORD_MARKS = "meta_word_marks"
+}
+export declare enum SpeechProvider {
+    AWS = "aws",
+    ELEVEN_LABS = "eleven_labs"
+}
+export declare enum SpeechEngine {
+    STANDARD = "standard",
+    NEURAL = "neural"
+}
+export declare enum SpeechLanguage {
+    ENGLISH = "English"
+}
+export declare enum SpeechDialect {
+    US = "US",
+    AU = "AU",
+    GB = "GB",
+    IN = "IN"
+}
+export declare enum SpeechGender {
+    MALE = "Male",
+    FEMALE = "Female"
+}
+export declare enum SpeechAge {
+    ADULT = "Adult",
+    CHILD = "Child",
+    ELDERLY = "Elderly"
+}
+export interface SpeechMarkItem {
+    time: number;
+    type: string;
+    start: number;
+    end: number;
+    value: string;
+}
+export declare class SpeechPersona {
+    static readonly AMY: SpeechPersona;
+    static readonly BRIAN: SpeechPersona;
+    static readonly EMMA: SpeechPersona;
+    static readonly IVY: SpeechPersona;
+    static readonly JOANNA: SpeechPersona;
+    static readonly JOEY: SpeechPersona;
+    static readonly JUSTIN: SpeechPersona;
+    static readonly KENDRA: SpeechPersona;
+    static readonly KEVIN: SpeechPersona;
+    static readonly KIMBERY: SpeechPersona;
+    static readonly MATTHEW: SpeechPersona;
+    static readonly SALLI: SpeechPersona;
+    static readonly DAVID: SpeechPersona;
+    static readonly RACHEL: SpeechPersona;
+    static readonly DEFAULT: SpeechPersona;
+    static readonly ALL: SpeechPersona[];
+    code: string;
+    name: string;
+    provider: SpeechProvider;
+    engine: SpeechEngine;
+    language: SpeechLanguage;
+    dialect: SpeechDialect;
+    gender: SpeechGender;
+    age: SpeechAge;
+    constructor(code: string, name: string, provider: SpeechProvider, engine: SpeechEngine, language: SpeechLanguage, dialect: SpeechDialect, gender: SpeechGender, age: SpeechAge);
+    static byName(name: string): SpeechPersona;
+    getLangaugeCode(): string;
+}

package/dist/models/content/Speech.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechPersona = exports.SpeechAge = exports.SpeechGender = exports.SpeechDialect = exports.SpeechLanguage = exports.SpeechEngine = exports.SpeechProvider = exports.SpeechDataType = void 0;
+var SpeechDataType;
+(function (SpeechDataType) {
+    SpeechDataType["AUDIO_MP3"] = "audio_mp3";
+    SpeechDataType["AUDIO_OGG"] = "audio_ogg";
+    SpeechDataType["META_WORD_MARKS"] = "meta_word_marks";
+})(SpeechDataType || (exports.SpeechDataType = SpeechDataType = {}));
+var SpeechProvider;
+(function (SpeechProvider) {
+    SpeechProvider["AWS"] = "aws";
+    SpeechProvider["ELEVEN_LABS"] = "eleven_labs";
+})(SpeechProvider || (exports.SpeechProvider = SpeechProvider = {}));
+var SpeechEngine;
+(function (SpeechEngine) {
+    SpeechEngine["STANDARD"] = "standard";
+    SpeechEngine["NEURAL"] = "neural";
+})(SpeechEngine || (exports.SpeechEngine = SpeechEngine = {}));
+;
+var SpeechLanguage;
+(function (SpeechLanguage) {
+    SpeechLanguage["ENGLISH"] = "English";
+})(SpeechLanguage || (exports.SpeechLanguage = SpeechLanguage = {}));
+;
+var SpeechDialect;
+(function (SpeechDialect) {
+    SpeechDialect["US"] = "US";
+    SpeechDialect["AU"] = "AU";
+    SpeechDialect["GB"] = "GB";
+    SpeechDialect["IN"] = "IN";
+})(SpeechDialect || (exports.SpeechDialect = SpeechDialect = {}));
+var SpeechGender;
+(function (SpeechGender) {
+    SpeechGender["MALE"] = "Male";
+    SpeechGender["FEMALE"] = "Female";
+})(SpeechGender || (exports.SpeechGender = SpeechGender = {}));
+var SpeechAge;
+(function (SpeechAge) {
+    SpeechAge["ADULT"] = "Adult";
+    SpeechAge["CHILD"] = "Child";
+    SpeechAge["ELDERLY"] = "Elderly";
+})(SpeechAge || (exports.SpeechAge = SpeechAge = {}));
+class SpeechPersona {
+    constructor(code, name, provider, engine, language, dialect, gender, age) {
+        this.code = code;
+        this.name = name;
+        this.provider = provider;
+        this.engine = engine;
+        this.language = language;
+        this.dialect = dialect;
+        this.gender = gender;
+        this.age = age;
+    }
+    static byName(name) {
+        name = name.toLowerCase();
+        for (let i = 0; i < SpeechPersona.ALL.length; i++) {
+            const persona = SpeechPersona.ALL[i];
+            if (persona.name.toLowerCase() == name) {
+                return persona;
+            }
+        }
+        return null;
+    }
+    getLangaugeCode() {
+        if (this.language === SpeechLanguage.ENGLISH) {
+            if (this.dialect === SpeechDialect.US) {
+                return "en-US";
+            }
+            else if (this.dialect === SpeechDialect.GB) {
+                return "en-GB";
+            }
+        }
+        return null;
+    }
+}
+exports.SpeechPersona = SpeechPersona;
+SpeechPersona.AMY = new SpeechPersona("00", "Amy", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.GB, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.BRIAN = new SpeechPersona("01", "Brian", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.GB, SpeechGender.MALE, SpeechAge.ADULT);
+SpeechPersona.EMMA = new SpeechPersona("02", "Emma", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.GB, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.IVY = new SpeechPersona("03", "Ivy", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.FEMALE, SpeechAge.CHILD);
+SpeechPersona.JOANNA = new SpeechPersona("04", "Joanna", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.JOEY = new SpeechPersona("05", "Joey", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.MALE, SpeechAge.ADULT);
+SpeechPersona.JUSTIN = new SpeechPersona("06", "Justin", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.MALE, SpeechAge.CHILD);
+SpeechPersona.KENDRA = new SpeechPersona("07", "Kendra", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.KEVIN = new SpeechPersona("08", "Kevin", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.MALE, SpeechAge.CHILD);
+SpeechPersona.KIMBERY = new SpeechPersona("09", "Kimberly", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.MATTHEW = new SpeechPersona("0a", "Matthew", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.MALE, SpeechAge.ADULT);
+SpeechPersona.SALLI = new SpeechPersona("0b", "Salli", SpeechProvider.AWS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.DAVID = new SpeechPersona("5FlhwUeTKmBbKy4nphG3", "David", SpeechProvider.ELEVEN_LABS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.MALE, SpeechAge.ADULT);
+SpeechPersona.RACHEL = new SpeechPersona("nTeH5Tfb8NMpR0YHgOSI", "Rachel", SpeechProvider.ELEVEN_LABS, SpeechEngine.NEURAL, SpeechLanguage.ENGLISH, SpeechDialect.US, SpeechGender.FEMALE, SpeechAge.ADULT);
+SpeechPersona.DEFAULT = SpeechPersona.JOANNA;
+SpeechPersona.ALL = [
+    SpeechPersona.AMY, SpeechPersona.BRIAN, SpeechPersona.EMMA, SpeechPersona.IVY, SpeechPersona.JOANNA, SpeechPersona.JOEY,
+    SpeechPersona.JUSTIN, SpeechPersona.KENDRA, SpeechPersona.KEVIN, SpeechPersona.KIMBERY, SpeechPersona.MATTHEW, SpeechPersona.SALLI,
+    SpeechPersona.DAVID, SpeechPersona.RACHEL
+];

package/dist/models/content/Stub.d.ts

@@ -0,0 +1,24 @@
+import { ArrayView } from "./ArrayView";
+import { ContentId, ContentRef } from "./Content";
+import { ContentKind } from "./ContentKind";
+export interface Stub {
+    kind: ContentKind;
+    label: string;
+    parent?: ContentId;
+    children?: Stub[];
+}
+export interface FolderStub extends Stub {
+    id: ContentId;
+}
+export interface ContentStub extends Stub {
+    category?: string;
+    ref: ContentRef;
+}
+export declare class Stubs {
+    static idFromStub(stub: Stub): ContentId;
+    static refFromStub(stub: Stub): ContentRef;
+    static unflatten(stubs: Stub[]): Stub[];
+    static isFolderStub(stub: Stub): boolean;
+    static isContentStub(stub: Stub): boolean;
+    static insertStubAtActivePoint(stub: Stub, stubArrayView: ArrayView<Stub>, category: string, activeId: ContentId, defaultAtBeginning: boolean): number;
+}