@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Comment.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comment = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const Operation_1 = require("../markup/Operation");
+const ContentKind_1 = require("./ContentKind");
+const RichText_1 = require("./RichText");
+const Time_1 = require("./Time");
+class Comment extends RichText_1.RichText {
+    static create(userId, anchorContentRef) {
+        const now = Time_1.MultiClock.now();
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        const commentId = shareSync.makeContentId();
+        return shareSync.createContent({
+            meta: {
+                ref: commentId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.COMMENT,
+                id: commentId,
+                owner: userId,
+                created_at: now,
+                updated_at: now,
+                checkpoints: []
+            },
+            payload: {
+                anchor: anchorContentRef,
+                richtext_flavor: RichText_1.RichTextFlavor.quill,
+                richtext_body: { ops: [] },
+                word_count: 0
+            }
+        });
+    }
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("Comment.payload");
+        return this.doc.data.payload;
+    }
+    get anchor() {
+        this.checkDisposed("Comment.anchor");
+        return this.payload.anchor;
+    }
+    setAnchor(value) {
+        this.checkDisposed("Comment.setAnchor");
+        if (this.anchor !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'anchor'], value);
+            batch.commit();
+        }
+    }
+}
+exports.Comment = Comment;

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

@@ -0,0 +1,31 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { ArrayView } from './ArrayView';
+import { ContentBody, ContentId, ContentMeta, ContentRef } from './Content';
+import { MediaCropping } from './Media';
+import { RichText, RichTextPayload } from './RichText';
+export interface ConceptArtPayload extends RichTextPayload {
+    name: string;
+    media_ref: ContentRef;
+    references: ContentRef[];
+    cropping: MediaCropping;
+}
+export interface ConceptArtBody extends ContentBody {
+    meta: ContentMeta;
+    payload: ConceptArtPayload;
+}
+export declare class ConceptArt extends RichText {
+    private _referencesView;
+    constructor(doc: Doc, isCreating: boolean, shareSync: ShareSync);
+    get payload(): ConceptArtPayload;
+    static create(userId: ContentId, conceptArtId: ContentId, payload: ConceptArtPayload): ConceptArt;
+    static makeConceptArtIdForMedia(mediaId: ContentId): ContentId;
+    get name(): string;
+    setName(value: string, newWordCount: number): void;
+    get mediaRef(): ContentId;
+    get cropping(): MediaCropping;
+    setCropping(value: MediaCropping): void;
+    get references(): ArrayView<ContentRef>;
+    updateReferrer(referrerRef: ContentRef): Promise<void>;
+}

package/dist/models/content/ConceptArt.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConceptArt = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const Operation_1 = require("../markup/Operation");
+const ArrayView_1 = require("./ArrayView");
+const ContentKind_1 = require("./ContentKind");
+const RichText_1 = require("./RichText");
+const Time_1 = require("./Time");
+class ConceptArt extends RichText_1.RichText {
+    constructor(doc, isCreating, shareSync) {
+        super(doc, isCreating, shareSync);
+        this._referencesView = new ArrayView_1.ArrayView(this, ['payload', 'references']);
+    }
+    get payload() {
+        this.checkDisposed("ConceptArt.payload");
+        return this.doc.data.payload;
+    }
+    static create(userId, conceptArtId, payload) {
+        const now = Time_1.MultiClock.now();
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: conceptArtId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.CONCEPT_ART,
+                id: conceptArtId,
+                owner: userId,
+                created_at: now,
+                updated_at: now,
+                checkpoints: []
+            },
+            payload: payload
+        });
+    }
+    static makeConceptArtIdForMedia(mediaId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(mediaId + "-" + ContentKind_1.ContentKind.CONCEPT_ART);
+    }
+    get name() {
+        this.checkDisposed("ConceptArt.name");
+        return this.payload.name;
+    }
+    setName(value, newWordCount) {
+        this.checkDisposed("ConceptArt.setName");
+        if (this.name != value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(['payload', 'name'], value);
+            if (this.wordCount != newWordCount) {
+                batch.setPathValue(['payload', 'word_count'], newWordCount);
+            }
+            batch.commit();
+        }
+    }
+    get mediaRef() {
+        this.checkDisposed("ConceptArt.mediaRef");
+        return this.payload.media_ref;
+    }
+    get cropping() {
+        this.checkDisposed("ConceptArt.cropping");
+        return this.payload.cropping;
+    }
+    setCropping(value) {
+        this.checkDisposed("ConceptArt.setCropping");
+        if (this.cropping !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'cropping'], value);
+            batch.commit();
+        }
+    }
+    get references() {
+        this.checkDisposed("ConceptArt.references");
+        return this._referencesView;
+    }
+    async updateReferrer(referrerRef) {
+        this.checkDisposed("ConceptArt.updateReferrer");
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        const fragment = await shareSync.acquire(ContentKind_1.ContentKind.FRAGMENT, referrerRef);
+        if (fragment.gallery.indexOf(this.id) < 0) {
+            fragment.gallery.push(this.id);
+        }
+        fragment.release();
+    }
+}
+exports.ConceptArt = ConceptArt;

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

@@ -0,0 +1,52 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { BillingPayload } from "./Billing";
+import { ContentKind } from './ContentKind';
+import { DevicePayload } from './Device';
+import { HanziPayload } from './Hanzi';
+import { Model } from './Model';
+import { PhrasePayload } from './Phrase';
+import { ProfilePayload } from "./Profile";
+import { CompactDateTime, MultiTime } from './Time';
+import { UserPayload } from './User';
+import { MediaPayload } from './Media';
+declare enum ContentIdBrand {
+}
+declare enum ContentRefBrand {
+}
+export type ContentId = string & ContentIdBrand;
+export type ContentRef = (string & ContentRefBrand) | ContentId;
+export interface ParsedContentRef {
+    id: ContentId;
+    kind?: ContentKind;
+    timestamp?: CompactDateTime;
+}
+export interface ContentBody {
+    meta: ContentMeta;
+    payload: ContentPayload;
+}
+export interface ContentMeta {
+    ref: ContentRef;
+    kind: ContentKind;
+    is_head: boolean;
+    id: ContentId;
+    owner: ContentId;
+    created_at: MultiTime;
+    updated_at: MultiTime;
+}
+export type ContentPayload = BillingPayload | HanziPayload | PhrasePayload | DevicePayload | MediaPayload | ProfilePayload | UserPayload;
+export declare abstract class Content extends Model {
+    static ID_LENGTH: number;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get isHead(): boolean;
+    get meta(): ContentMeta;
+    get payload(): ContentPayload;
+    cloneContentBody(): ContentBody;
+    get id(): ContentId;
+    get updatedAt(): MultiTime;
+    get createdAt(): MultiTime;
+    get owner(): ContentId;
+    modelUpdated(): Promise<void>;
+}
+export {};

package/dist/models/content/Content.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Content = void 0;
+const Struct_1 = require("../../util/Struct");
+const Model_1 = require("./Model");
+var ContentIdBrand;
+(function (ContentIdBrand) {
+})(ContentIdBrand || (ContentIdBrand = {}));
+var ContentRefBrand;
+(function (ContentRefBrand) {
+})(ContentRefBrand || (ContentRefBrand = {}));
+class Content extends Model_1.Model {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get isHead() {
+        this.checkDisposed("Content.isHead");
+        return this.meta.is_head;
+    }
+    get meta() {
+        this.checkDisposed("Content.meta");
+        return this.doc.data.meta;
+    }
+    get payload() {
+        this.checkDisposed("Content.payload");
+        return this.doc.data.payload;
+    }
+    cloneContentBody() {
+        this.checkDisposed("Content.cloneContentBody");
+        if (this.exists()) {
+            return Struct_1.Struct.clone(this.doc.data);
+        }
+        else {
+            return null;
+        }
+    }
+    get id() {
+        this.checkDisposed("Content.id");
+        return this.meta.id;
+    }
+    get updatedAt() {
+        this.checkDisposed("Content.updatedAt");
+        return this.meta.updated_at;
+    }
+    get createdAt() {
+        this.checkDisposed("Content.createdAt");
+        return this.meta.created_at;
+    }
+    get owner() {
+        this.checkDisposed("Content.owner");
+        return this.meta.owner;
+    }
+    async modelUpdated() {
+        this.checkDisposed("Content.modelUpdated");
+        this.acquire();
+        await this.shareSync.updateManifestForContent(this);
+        this.release();
+    }
+}
+exports.Content = Content;
+Content.ID_LENGTH = 16;

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

@@ -0,0 +1,10 @@
+export declare enum ContentKind {
+    BILLING = "billing",
+    DEVICE = "device",
+    METRIC = "metric",
+    PROFILE = "profile",
+    SESSION = "session",
+    USER = "user",
+    MEDIA = "media",
+    MANIFEST = "manifest"
+}

package/dist/models/content/ContentKind.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentKind = void 0;
+var ContentKind;
+(function (ContentKind) {
+    // These are all the current Content subclasses
+    ContentKind["BILLING"] = "billing";
+    ContentKind["DEVICE"] = "device";
+    ContentKind["METRIC"] = "metric";
+    ContentKind["PROFILE"] = "profile";
+    ContentKind["SESSION"] = "session";
+    ContentKind["USER"] = "user";
+    ContentKind["MEDIA"] = "media";
+    // These are used in the ShareDB system, but for internal bookkeeping, not for Content subclasses.
+    ContentKind["MANIFEST"] = "manifest";
+})(ContentKind || (exports.ContentKind = ContentKind = {}));

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

@@ -0,0 +1,28 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { JsonPath } from '../markup/Operation';
+import { ArrayView } from './ArrayView';
+import { BookPayload, BookStubArrayKey } from './Book';
+import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
+import { Stub } from "./Stub";
+import { WorkspacePayload, WorkspaceStubArrayKey } from './Workspace';
+export type StubArrayKey = BookStubArrayKey | WorkspaceStubArrayKey;
+export interface ContextBody extends ContentBody {
+    meta: ContentMeta;
+    payload: WorkspacePayload | BookPayload;
+}
+export declare abstract class Context extends Content {
+    protected _trashView: ArrayView<Stub>;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get trash(): ArrayView<Stub>;
+    abstract getStubArrayKeys(): StubArrayKey[];
+    abstract getStubArrayView(key: StubArrayKey): ArrayView<Stub>;
+    findPathToStub(ref: ContentRef): JsonPath;
+    removeStubAtPath(path: JsonPath, moveToTrash: boolean): void;
+    getStubAtPath(path: JsonPath): Stub;
+    setStubFieldValue(ref: ContentRef, fieldName: string, value: any): void;
+    editStubFieldText(ref: ContentRef, fieldName: string, value: string): void;
+    addFolder(stub: Stub, key: StubArrayKey, activeId?: ContentId): void;
+    mergeIncomingContext(incomingContextBody: ContextBody): boolean;
+}

package/dist/models/content/Context.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const Struct_1 = require("../../util/Struct");
+const Operation_1 = require("../markup/Operation");
+const ArrayView_1 = require("./ArrayView");
+const Content_1 = require("./Content");
+const Stub_1 = require("./Stub");
+class Context extends Content_1.Content {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+        this._trashView = new ArrayView_1.ArrayView(this, ['payload', 'trash']);
+    }
+    get trash() {
+        this.checkDisposed("Context.trash");
+        return this._trashView;
+    }
+    findPathToStub(ref) {
+        this.checkDisposed("Context.findPathToStub");
+        const arrayKeys = this.getStubArrayKeys();
+        for (let i = 0, len = arrayKeys.length; i < len; i++) {
+            const key = arrayKeys[i];
+            const view = this.getStubArrayView(key);
+            if (view) {
+                const index = view.firstIndexWhere((stub) => {
+                    return (Stub_1.Stubs.isContentStub(stub) && stub.ref == ref)
+                        || (Stub_1.Stubs.isFolderStub(stub) && stub.id == ref);
+                });
+                if (index >= 0) {
+                    return ['payload', key, index];
+                }
+            }
+        }
+        return null;
+    }
+    removeStubAtPath(path, moveToTrash) {
+        this.checkDisposed("Context.removeStubAtPath");
+        // Make sure this stub isn't already in the trash
+        const stubArrayKey = path[1];
+        if (stubArrayKey === "trash") {
+            return;
+        }
+        // If the stub has a parent, take note of it, so that we can reassign parentage for all orphans or the removed stub.
+        const stubToDelete = this.getStubAtPath(path);
+        const stubIdToDelete = Stub_1.Stubs.idFromStub(stubToDelete);
+        const grandparentId = stubToDelete.parent;
+        const batch = new Operation_1.BatchOperation(this);
+        // Reparent all stubs that previously referred to this stub as their parent.
+        // If this stub has no parent, then remove the parent property from all of its children.
+        const stubArrayView = this.getStubArrayView(stubArrayKey);
+        for (let i = 0, len = stubArrayView.length; i < len; i++) {
+            const stub = stubArrayView.get(i);
+            if (stub.parent === stubIdToDelete) {
+                const pathToParentProperty = ['payload', stubArrayKey, i, 'parent'];
+                if (grandparentId) {
+                    batch.replaceValueAtPath(pathToParentProperty, grandparentId);
+                }
+                else {
+                    batch.removeValueAtPath(pathToParentProperty);
+                }
+            }
+        }
+        // Remove the parentage of the deleted stub
+        if (grandparentId) {
+            const pathToParentProperty = Struct_1.Struct.clone(path);
+            pathToParentProperty.push('parent');
+            batch.removeValueAtPath(pathToParentProperty);
+        }
+        // Finally, either remove the deleted stub entirely, or move it to the trash.
+        if (moveToTrash) {
+            const trashStubCount = this._trashView.length;
+            batch.move(path, ['payload', 'trash', trashStubCount]);
+        }
+        else {
+            batch.removeValueAtPath(path);
+        }
+        batch.commit();
+    }
+    getStubAtPath(path) {
+        this.checkDisposed("Context.getStubAtPath");
+        return Operation_1.JsonPathSelect.getValueAtPath(this.doc, path);
+    }
+    setStubFieldValue(ref, fieldName, value) {
+        this.checkDisposed("Context.setStubFieldValue");
+        const path = this.findPathToStub(ref);
+        if (fieldName !== 'label' && fieldName != 'category') {
+            throw new Error(`setting unexpected fieldName '${fieldName}' to value ${JSON.stringify(value)}`);
+        }
+        if (path !== null) {
+            path.push(fieldName);
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(path, value);
+            batch.commit();
+        }
+    }
+    editStubFieldText(ref, fieldName, value) {
+        this.checkDisposed("Context.setStubFieldValue");
+        const path = this.findPathToStub(ref);
+        if (fieldName !== 'label' && fieldName != 'category') {
+            throw new Error(`setting unexpected fieldName '${fieldName}' to value '${value}'`);
+        }
+        if (path !== null) {
+            path.push(fieldName);
+            const batch = new Operation_1.BatchOperation(this);
+            batch.editPathText(path, value);
+            batch.commit();
+        }
+    }
+    addFolder(stub, key, activeId) {
+        this.checkDisposed("Context.addFolder");
+        const stubArrayView = this.getStubArrayView(key);
+        Stub_1.Stubs.insertStubAtActivePoint(stub, stubArrayView, null, activeId, false);
+    }
+    mergeIncomingContext(incomingContextBody) {
+        let madeChanges = false;
+        // First, gather all the refs in this context, so that we can find any new incoming
+        // stubs that might need to be merged. It's important that we look through all potential
+        // stub arrays, because any individual stub may have been moved between arrays. We only
+        // want to merge in new stubs if they don't already exist anywhere in this context.
+        const stubIds = new Set();
+        const stubArrayKeys = this.getStubArrayKeys();
+        for (let i = 0; i < stubArrayKeys.length; i++) {
+            const stubArrayKey = stubArrayKeys[i];
+            const stubArrayView = this.getStubArrayView(stubArrayKey);
+            stubArrayView.forEach((idx, stub) => {
+                stubIds.add(Stub_1.Stubs.idFromStub(stub));
+            });
+        }
+        // Next, merge in any new stubs from the incoming context.
+        const incomingPayload = incomingContextBody.payload;
+        for (let i = 0; i < stubArrayKeys.length; i++) {
+            const stubArrayKey = stubArrayKeys[i];
+            const stubArrayView = this.getStubArrayView(stubArrayKey);
+            if (incomingPayload.hasOwnProperty(stubArrayKey)) {
+                const incomingStubArray = incomingPayload[stubArrayKey];
+                for (let j = 0; j < incomingStubArray.length; j++) {
+                    const incomingStub = incomingStubArray[j];
+                    const incomingStubId = Stub_1.Stubs.idFromStub(incomingStub);
+                    if (!stubIds.has(incomingStubId)) {
+                        // This stub is not currently present in this context, so merge it in. We will
+                        // attempt to add it to the corrent position in the array, but it's possible
+                        // that the array has been reordered, so insertion of this stub might not be in
+                        // quite the right position. But we're just trying to make sure that the stubs
+                        // are all present, and this capabililty is only being included as a way of
+                        // recovering from a migration bug that only affected a small number of users.
+                        if (j < stubArrayView.length) {
+                            stubArrayView.insert(j, incomingStub);
+                        }
+                        else {
+                            stubArrayView.push(incomingStub);
+                        }
+                        // Add the new stub to the set of stubs we've already seen
+                        stubIds.add(incomingStubId);
+                        madeChanges = true;
+                    }
+                }
+            }
+        }
+        return madeChanges;
+    }
+}
+exports.Context = Context;

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

@@ -0,0 +1,5 @@
+export declare enum DevEnv {
+    LOCAL = "LOCAL",
+    STAGING = "STAGING",
+    PRODUCTION = "PRODUCTION"
+}

package/dist/models/content/DevEnv.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevEnv = void 0;
+var DevEnv;
+(function (DevEnv) {
+    DevEnv["LOCAL"] = "LOCAL";
+    DevEnv["STAGING"] = "STAGING";
+    DevEnv["PRODUCTION"] = "PRODUCTION";
+})(DevEnv || (exports.DevEnv = DevEnv = {}));

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

@@ -0,0 +1,24 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { CompactDateTime } from './Time';
+export interface LastSync {
+    at_utc_time: CompactDateTime;
+}
+export interface DevicePayload {
+    last_sync?: LastSync;
+}
+export interface DeviceBody extends ContentBody {
+    meta: ContentMeta;
+    payload: DevicePayload;
+}
+export declare class Device extends Content {
+    static makeProfleId(userId: ContentId): ContentId;
+    static create(userId: ContentId, deviceId: ContentId, theme: string, typeface: string, typesize: string): Device;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): DevicePayload;
+    get lastSyncAtUtcTime(): CompactDateTime;
+    setLastSyncAtUtcTime(value: CompactDateTime): void;
+    private ensureLastSyncAtUtcTimeExists;
+}

package/dist/models/content/Device.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = 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 Device extends Content_1.Content {
+    static makeProfleId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.PROFILE);
+    }
+    static create(userId, deviceId, theme, typeface, typesize) {
+        const now = Time_1.MultiClock.now();
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: deviceId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.DEVICE,
+                id: deviceId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                last_sync: { at_utc_time: null }
+            }
+        });
+    }
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    get payload() {
+        this.checkDisposed("Device.payload");
+        return this.doc.data.payload;
+    }
+    get lastSyncAtUtcTime() {
+        this.checkDisposed("Device.lastSyncAtUtcTime");
+        this.ensureLastSyncAtUtcTimeExists();
+        return this.payload.last_sync.at_utc_time;
+    }
+    setLastSyncAtUtcTime(value) {
+        this.checkDisposed("Device.setLastSyncAtUtcTime");
+        this.ensureLastSyncAtUtcTimeExists();
+        if (this.lastSyncAtUtcTime !== value) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'last_sync', 'at_utc_time'], value);
+            batch.commit();
+        }
+    }
+    ensureLastSyncAtUtcTimeExists() {
+        this.checkDisposed("Device.ensureLastSyncAtUtcTimeExists");
+        // If the 'last_sync' field doesn't exist, add it first...
+        if (!this.payload.hasOwnProperty('last_sync')) {
+            const batch = new Operation_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'last_sync'], { at_utc_time: null });
+            batch.commit();
+        }
+    }
+}
+exports.Device = Device;

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

@@ -0,0 +1,31 @@
+import { ContentMeta } from "./Content";
+declare enum DictionaryIdBrand {
+}
+export type DictionaryId = (string & DictionaryIdBrand) | null;
+export interface DictionaryEntry {
+    text: string;
+    repl?: string;
+    freq?: number;
+    score?: number;
+    phon?: string;
+}
+export interface ResolvedDictionary {
+    entries: {
+        [key: string]: DictionaryEntry;
+    };
+}
+export interface DictionaryBody {
+    meta: ContentMeta;
+    payload: DictionaryPayload;
+}
+export interface DictionaryPayload {
+    id: string;
+    name: string;
+    include_dicts: DictionaryId[];
+    exclude_keys: string[];
+    entries: DictionaryEntry[];
+}
+export interface Dictionary extends DictionaryPayload {
+    resolved?: ResolvedDictionary;
+}
+export {};

package/dist/models/content/Dictionary.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var DictionaryIdBrand;
+(function (DictionaryIdBrand) {
+})(DictionaryIdBrand || (DictionaryIdBrand = {}));

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

@@ -0,0 +1,20 @@
+export interface DictionaryEntry {
+    text: string;
+    rank: number;
+    learn_rank: number;
+    is_starred?: boolean;
+    tags: string[];
+}
+export interface Pronouncable {
+    pinyin: string;
+    pinyin_tokenized?: string;
+    pinyin_normalized: string;
+}
+export interface Definable {
+    definition: string;
+    definition_analysis: string;
+    translation?: string;
+    transliteration?: string;
+    function?: string;
+    usage?: string;
+}

package/dist/models/content/DictionaryEntry.js

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