@shaxpir/duiduidui-models 1.0.0

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

@@ -0,0 +1,71 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from "../../repo/ShareSync";
+import { ArrayView } from './ArrayView';
+import { Book } from "./Book";
+import { ContentBody, ContentId, ContentMeta } from './Content';
+import { Context } from './Context';
+import { Fragment } from "./Fragment";
+import { Session } from "./Session";
+import { Stub } from "./Stub";
+import { CompactDate, CompactDateTime, MultiTime } from './Time';
+export interface JourneyEntry {
+    key: string;
+    at_utc_time: CompactDateTime;
+}
+export interface WorkspacePayload {
+    devices: ContentId[];
+    books: Stub[];
+    shorts: Stub[];
+    articles: Stub[];
+    poems: Stub[];
+    ideas: Stub[];
+    trash: Stub[];
+    sessions: MultiTime[];
+    journey?: {
+        [key: string]: CompactDateTime;
+    };
+}
+export interface WorkspaceBody extends ContentBody {
+    meta: ContentMeta;
+    payload: WorkspacePayload;
+}
+export declare enum WorkspaceStubArrayKey {
+    BOOKS = "books",
+    SHORTS = "shorts",
+    ARTICLES = "articles",
+    POEMS = "poems",
+    IDEAS = "ideas",
+    TRASH = "trash"
+}
+export declare class Workspace extends Context {
+    private _articlesView;
+    private _booksView;
+    private _ideasView;
+    private _poemsView;
+    private _shortsView;
+    private _devicesView;
+    private _sessionsView;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): WorkspacePayload;
+    static makeWorkspaceId(userId: ContentId): ContentId;
+    static create(userId: ContentId, deviceId: ContentId): Workspace;
+    ensureLatestSchema(): Workspace;
+    get articles(): ArrayView<Stub>;
+    get books(): ArrayView<Stub>;
+    get ideas(): ArrayView<Stub>;
+    get poems(): ArrayView<Stub>;
+    get shorts(): ArrayView<Stub>;
+    get sessions(): ArrayView<MultiTime>;
+    getStubArrayKeys(): WorkspaceStubArrayKey[];
+    getStubArrayView(key: WorkspaceStubArrayKey): ArrayView<Stub>;
+    get devices(): ArrayView<ContentId>;
+    addBook(book: Book, activeId: ContentId): void;
+    addFragment(fragment: Fragment, stubArrayKey: WorkspaceStubArrayKey, activeId: ContentId): void;
+    acquireSessionsFromDate(sessionId: ContentId, localDate: CompactDate): Promise<Session[]>;
+    isBookFolderId(id: ContentId): boolean;
+    hasJourneyDate(journeyKey: string): boolean;
+    getJourneyDate(journeyKey: string): CompactDateTime;
+    setJourneyDate(journeyKey: string, journeyDate: CompactDateTime): void;
+    mergeIncomingContext(incomingWorkspace: WorkspaceBody): boolean;
+}

package/dist/models/content/Workspace.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspace = exports.WorkspaceStubArrayKey = 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 Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Context_1 = require("./Context");
+const Stub_1 = require("./Stub");
+const Time_1 = require("./Time");
+var WorkspaceStubArrayKey;
+(function (WorkspaceStubArrayKey) {
+    WorkspaceStubArrayKey["BOOKS"] = "books";
+    WorkspaceStubArrayKey["SHORTS"] = "shorts";
+    WorkspaceStubArrayKey["ARTICLES"] = "articles";
+    WorkspaceStubArrayKey["POEMS"] = "poems";
+    WorkspaceStubArrayKey["IDEAS"] = "ideas";
+    WorkspaceStubArrayKey["TRASH"] = "trash";
+})(WorkspaceStubArrayKey || (exports.WorkspaceStubArrayKey = WorkspaceStubArrayKey = {}));
+class Workspace extends Context_1.Context {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+        this._articlesView = new ArrayView_1.ArrayView(this, ['payload', 'articles']);
+        this._booksView = new ArrayView_1.ArrayView(this, ['payload', 'books']);
+        this._ideasView = new ArrayView_1.ArrayView(this, ['payload', 'ideas']);
+        this._poemsView = new ArrayView_1.ArrayView(this, ['payload', 'poems']);
+        this._shortsView = new ArrayView_1.ArrayView(this, ['payload', 'shorts']);
+        this._devicesView = new ArrayView_1.ArrayView(this, ['payload', 'devices']);
+        this._sessionsView = new ArrayView_1.ArrayView(this, ['payload', 'sessions']);
+    }
+    get payload() {
+        return this.doc.data.payload;
+    }
+    static makeWorkspaceId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.WORKSPACE);
+    }
+    static create(userId, deviceId) {
+        const now = Time_1.MultiClock.now();
+        const workspaceId = Workspace.makeWorkspaceId(userId);
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: workspaceId,
+                is_head: true,
+                kind: ContentKind_1.ContentKind.WORKSPACE,
+                id: workspaceId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                devices: [deviceId],
+                journey: {},
+                books: [],
+                shorts: [],
+                articles: [],
+                poems: [],
+                ideas: [],
+                sessions: [],
+                trash: []
+            }
+        });
+    }
+    ensureLatestSchema() {
+        let batch = null;
+        if (this.payload.hasOwnProperty('primary_device')) {
+            if (!batch) {
+                batch = new Operation_1.BatchOperation(this);
+            }
+            batch.removeValueAtPath(['payload', 'primary_device']);
+        }
+        if (this.payload.hasOwnProperty('primary_device_last_update')) {
+            if (!batch) {
+                batch = new Operation_1.BatchOperation(this);
+            }
+            batch.removeValueAtPath(['payload', 'primary_device_last_update']);
+        }
+        if (!this.payload.hasOwnProperty('journey')) {
+            if (!batch) {
+                batch = new Operation_1.BatchOperation(this);
+            }
+            batch.setPathValue(['payload', 'journey'], {});
+        }
+        if (batch != null) {
+            batch.commit();
+        }
+        return this;
+    }
+    get articles() {
+        this.checkDisposed("Workspace.articles");
+        return this._articlesView;
+    }
+    get books() {
+        this.checkDisposed("Workspace.books");
+        return this._booksView;
+    }
+    get ideas() {
+        this.checkDisposed("Workspace.ideas");
+        return this._ideasView;
+    }
+    get poems() {
+        this.checkDisposed("Workspace.poems");
+        return this._poemsView;
+    }
+    get shorts() {
+        this.checkDisposed("Workspace.shorts");
+        return this._shortsView;
+    }
+    get sessions() {
+        this.checkDisposed("Workspace.sessions");
+        return this._sessionsView;
+    }
+    getStubArrayKeys() {
+        return [
+            WorkspaceStubArrayKey.ARTICLES,
+            WorkspaceStubArrayKey.BOOKS,
+            WorkspaceStubArrayKey.IDEAS,
+            WorkspaceStubArrayKey.POEMS,
+            WorkspaceStubArrayKey.SHORTS,
+            WorkspaceStubArrayKey.TRASH
+        ];
+    }
+    getStubArrayView(key) {
+        this.checkDisposed("Workspace.getStubArrayView");
+        if (key === WorkspaceStubArrayKey.ARTICLES) {
+            return this.articles;
+        }
+        else if (key === WorkspaceStubArrayKey.BOOKS) {
+            return this.books;
+        }
+        else if (key === WorkspaceStubArrayKey.IDEAS) {
+            return this.ideas;
+        }
+        else if (key === WorkspaceStubArrayKey.POEMS) {
+            return this.poems;
+        }
+        else if (key === WorkspaceStubArrayKey.SHORTS) {
+            return this.shorts;
+        }
+        else if (key === WorkspaceStubArrayKey.TRASH) {
+            return this.trash;
+        }
+        return null;
+    }
+    // NOTE: As the user adds devices, we will always add new devices to the end of the array.
+    // So the most-recently-added device will always be at the end.
+    get devices() {
+        this.checkDisposed("Workspace.devices");
+        return this._devicesView;
+    }
+    addBook(book, activeId) {
+        this.checkDisposed("Workspace.addBook");
+        Stub_1.Stubs.insertStubAtActivePoint(book.asStub(), this._booksView, null, activeId, true);
+    }
+    addFragment(fragment, stubArrayKey, activeId) {
+        this.checkDisposed("Workspace.addFragment");
+        const stubArrayView = this.getStubArrayView(stubArrayKey);
+        const stub = fragment.asStub();
+        Stub_1.Stubs.insertStubAtActivePoint(stub, stubArrayView, fragment.category, activeId, true);
+    }
+    async acquireSessionsFromDate(sessionId, localDate) {
+        this.checkDisposed("Workspace.loadSessionsFromDate");
+        const shareSync = ShareSync_1.ShareSyncFactory.get();
+        const sessions = [];
+        for (let i = 0, len = this.sessions.length; i < len; i++) {
+            const sessionCreatedAt = this.sessions.get(i);
+            const sessionCreatedLocalDate = Time_1.Time.dateFrom(sessionCreatedAt.local_time);
+            if (localDate == sessionCreatedLocalDate) {
+                const sessionRef = Content_1.Content.makeContentRef(sessionId, sessionCreatedAt.utc_time);
+                const session = await shareSync.acquire(ContentKind_1.ContentKind.SESSION, sessionRef);
+                sessions.push(session);
+            }
+        }
+        return sessions;
+    }
+    isBookFolderId(id) {
+        this.checkDisposed("Workspace.isBookFolderId");
+        for (let i = 0, len = this.books.length; i < len; i++) {
+            const stub = this.books.get(i);
+            if (Stub_1.Stubs.isFolderStub(stub) && stub.id === id) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasJourneyDate(journeyKey) {
+        this.checkDisposed("Workspace.hasJourneyDate");
+        return this.payload.hasOwnProperty('journey') && this.payload.journey.hasOwnProperty(journeyKey);
+    }
+    getJourneyDate(journeyKey) {
+        this.checkDisposed("Workspace.getJourneyDate");
+        if (this.payload.hasOwnProperty('journey')) {
+            if (this.payload.journey.hasOwnProperty(journeyKey)) {
+                return this.payload.journey[journeyKey];
+            }
+        }
+        return null;
+    }
+    setJourneyDate(journeyKey, journeyDate) {
+        this.checkDisposed("Workspace.setJourneyDate");
+        const batch = new Operation_1.BatchOperation(this);
+        if (this.payload.hasOwnProperty('journey')) {
+            batch.setPathValue(['payload', 'journey', journeyKey], journeyDate);
+        }
+        else {
+            const journey = {};
+            journey[journeyKey] = journeyDate;
+            batch.setPathValue(['payload', 'journey'], journey);
+        }
+        batch.commit();
+    }
+    mergeIncomingContext(incomingWorkspace) {
+        let madeChanges = super.mergeIncomingContext(incomingWorkspace);
+        // Collect all the session timestamps already in this workspace.
+        const sessionUtcTimes = new Set();
+        this.sessions.forEach((idx, sessionAt) => {
+            sessionUtcTimes.add(sessionAt.utc_time);
+        });
+        // Now add any new session timestamps from the incoming workspace.
+        const incomingSessions = incomingWorkspace.payload.sessions;
+        for (let i = 0, len = incomingSessions.length; i < len; i++) {
+            const incomingSessionAt = incomingSessions[i];
+            if (!sessionUtcTimes.has(incomingSessionAt.utc_time)) {
+                if (i < this.sessions.length) {
+                    this.sessions.insert(i, incomingSessionAt);
+                }
+                else {
+                    this.sessions.push(incomingSessionAt);
+                }
+                madeChanges = true;
+            }
+        }
+        return madeChanges;
+    }
+}
+exports.Workspace = Workspace;

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

@@ -0,0 +1,36 @@
+export * from './Activity';
+export * from './ArrayView';
+export * from './Billing';
+export * from './Book';
+export * from './Category';
+export * from './Checkpointable';
+export * from './Comment';
+export * from './ConceptArt';
+export * from './Content';
+export * from './ContentKind';
+export * from './Context';
+export * from './DevEnv';
+export * from './Device';
+export * from './Dictionary';
+export * from './ElasticModel';
+export * from './Environment';
+export * from './ExportOptions';
+export * from './Folder';
+export * from './Fragment';
+export * from './GeoLocation';
+export * from './HighlightRule';
+export * from './Manifest';
+export * from './Media';
+export * from './Metric';
+export * from './Migration';
+export * from './Model';
+export * from './Permissions';
+export * from './Placeholder';
+export * from './Profile';
+export * from './RichText';
+export * from './Session';
+export * from './Speech';
+export * from './Stub';
+export * from './Time';
+export * from './User';
+export * from './Workspace';

package/dist/models/content/index.js

@@ -0,0 +1,53 @@
+"use strict";
+// created from 'create-ts-index'
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Activity"), exports);
+__exportStar(require("./ArrayView"), exports);
+__exportStar(require("./Billing"), exports);
+__exportStar(require("./Book"), exports);
+__exportStar(require("./Category"), exports);
+__exportStar(require("./Checkpointable"), exports);
+__exportStar(require("./Comment"), exports);
+__exportStar(require("./ConceptArt"), exports);
+__exportStar(require("./Content"), exports);
+__exportStar(require("./ContentKind"), exports);
+__exportStar(require("./Context"), exports);
+__exportStar(require("./DevEnv"), exports);
+__exportStar(require("./Device"), exports);
+__exportStar(require("./Dictionary"), exports);
+__exportStar(require("./ElasticModel"), exports);
+__exportStar(require("./Environment"), exports);
+__exportStar(require("./ExportOptions"), exports);
+__exportStar(require("./Folder"), exports);
+__exportStar(require("./Fragment"), exports);
+__exportStar(require("./GeoLocation"), exports);
+__exportStar(require("./HighlightRule"), exports);
+__exportStar(require("./Manifest"), exports);
+__exportStar(require("./Media"), exports);
+__exportStar(require("./Metric"), exports);
+__exportStar(require("./Migration"), exports);
+__exportStar(require("./Model"), exports);
+__exportStar(require("./Permissions"), exports);
+__exportStar(require("./Placeholder"), exports);
+__exportStar(require("./Profile"), exports);
+__exportStar(require("./RichText"), exports);
+__exportStar(require("./Session"), exports);
+__exportStar(require("./Speech"), exports);
+__exportStar(require("./Stub"), exports);
+__exportStar(require("./Time"), exports);
+__exportStar(require("./User"), exports);
+__exportStar(require("./Workspace"), exports);

package/dist/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from './content';
+export * from './legacy';
+export * from './markup';
+export * from './OutboundMessage';

package/dist/models/index.js

@@ -0,0 +1,21 @@
+"use strict";
+// created from 'create-ts-index'
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./content"), exports);
+__exportStar(require("./legacy"), exports);
+__exportStar(require("./markup"), exports);
+__exportStar(require("./OutboundMessage"), exports);

package/dist/models/legacy/LegacyBodyFormat.d.ts

@@ -0,0 +1,9 @@
+import { Format } from "../content/RichText";
+import { LegacyContent } from "./LegacyContent";
+export interface LegacyBodyFormatPayload {
+    body: string;
+    format: Format[];
+}
+export interface LegacyBodyFormat extends LegacyContent {
+    payload: LegacyBodyFormatPayload;
+}

package/dist/models/legacy/LegacyBodyFormat.js

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

package/dist/models/legacy/LegacyComment.d.ts

@@ -0,0 +1,12 @@
+import { MultiTime } from "../content/Time";
+import { LegacyBodyFormat, LegacyBodyFormatPayload } from "./LegacyBodyFormat";
+import { LegacyHeadLocator, LegacyLocator } from "./LegacyLocator";
+export interface LegacyCommentPayload extends LegacyBodyFormatPayload {
+    anchor: LegacyLocator | null;
+    word_count: number;
+    by: LegacyHeadLocator;
+    at: MultiTime;
+}
+export interface LegacyComment extends LegacyBodyFormat {
+    payload: LegacyCommentPayload;
+}

package/dist/models/legacy/LegacyComment.js

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

package/dist/models/legacy/LegacyContent.d.ts

@@ -0,0 +1,53 @@
+import { CompactDateTime, MultiTime } from "../content/Time";
+import { LegacyBodyFormatPayload } from "./LegacyBodyFormat";
+import { LegacyCommentPayload } from "./LegacyComment";
+import { LegacyFragmentPayload } from "./LegacyFragment";
+import { LegacyHeadLocator, LegacyLocator } from "./LegacyLocator";
+import { LegacyPicturePayload } from "./LegacyPicture";
+import { LegacyProfilePayload } from "./LegacyProfile";
+import { LegacySessionPayload } from "./LegacySession";
+import { LegacyStoryPayload } from "./LegacyStory";
+import { LegacyTransactionPayload } from "./LegacyTransaction";
+import { LegacyUserPayload } from "./LegacyUser";
+import { LegacyWorkspacePayload } from "./LegacyWorkspace";
+export type LegacyDateTime = string;
+export declare class LegacyClock {
+    static utcNow(): LegacyDateTime;
+    static fromCompact(value: CompactDateTime): LegacyDateTime;
+}
+export declare class LegacyMultiClock {
+    static utcNow(): LegacyMultiTime;
+    static fromModern(multiTime: MultiTime): LegacyMultiTime;
+}
+export interface LegacyMultiTime {
+    utc_time: LegacyDateTime;
+    local_time: LegacyDateTime;
+}
+export type LegacyPayload = LegacyBodyFormatPayload | LegacyCommentPayload | LegacyFragmentPayload | LegacyPicturePayload | LegacyStoryPayload | LegacyWorkspacePayload | LegacyProfilePayload | LegacySessionPayload | LegacyTransactionPayload | LegacyUserPayload;
+export declare enum LegacyContentKind {
+    COMMENT = "comment",
+    FOLDER = "folder",
+    FRAGMENT = "fragment",
+    PICTURE = "picture",
+    PROFILE = "profile",
+    SESSION = "session",
+    STORY = "story",
+    TRANSACTION = "transaction",
+    USER = "user",
+    WORKSPACE = "workspace"
+}
+export interface LegacyContent {
+    locator: LegacyLocator;
+    parent: LegacyLocator | null;
+    is_head: boolean;
+    sync_time: string | null;
+    kind: LegacyContentKind;
+    id: LegacyHeadLocator;
+    seq: number;
+    by: LegacyHeadLocator;
+    at: LegacyMultiTime;
+    model_version: number;
+    session: LegacyLocator | null;
+    permissions: string[];
+    payload: LegacyPayload;
+}

package/dist/models/legacy/LegacyContent.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyContentKind = exports.LegacyMultiClock = exports.LegacyClock = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+dayjs_1.default.extend(utc_1.default);
+const Time_1 = require("../content/Time");
+class LegacyClock {
+    static utcNow() {
+        return dayjs_1.default.utc().format(Time_1.Time.DATETIME_FORMAT_LEGACY);
+    }
+    static fromCompact(value) {
+        return dayjs_1.default.utc(value, Time_1.Time.DATETIME_FORMAT_COMPACT).format(Time_1.Time.DATETIME_FORMAT_LEGACY);
+    }
+}
+exports.LegacyClock = LegacyClock;
+class LegacyMultiClock {
+    static utcNow() {
+        let nowUtc = dayjs_1.default.utc().format(Time_1.Time.DATETIME_FORMAT_LEGACY);
+        const timestamp = dayjs_1.default.utc(nowUtc, Time_1.Time.DATETIME_FORMAT_LEGACY)
+            .local();
+        let nowLocal = timestamp.format(Time_1.Time.DATETIME_FORMAT_LEGACY);
+        return {
+            local_time: nowLocal,
+            utc_time: nowUtc
+        };
+    }
+    // TODO: Is this correct? It's going to return zero-offset (UTC zone)
+    // timestamps for both utc_time and local_time, no matter what the inputs
+    // are...  Perhaps we can just delete this method, it is not even being used,
+    // as far as I can tell
+    static fromModern(multiTime) {
+        return {
+            utc_time: LegacyClock.fromCompact(multiTime.utc_time),
+            local_time: LegacyClock.fromCompact(multiTime.local_time),
+        };
+    }
+}
+exports.LegacyMultiClock = LegacyMultiClock;
+var LegacyContentKind;
+(function (LegacyContentKind) {
+    LegacyContentKind["COMMENT"] = "comment";
+    LegacyContentKind["FOLDER"] = "folder";
+    LegacyContentKind["FRAGMENT"] = "fragment";
+    LegacyContentKind["PICTURE"] = "picture";
+    LegacyContentKind["PROFILE"] = "profile";
+    LegacyContentKind["SESSION"] = "session";
+    LegacyContentKind["STORY"] = "story";
+    LegacyContentKind["TRANSACTION"] = "transaction";
+    LegacyContentKind["USER"] = "user";
+    LegacyContentKind["WORKSPACE"] = "workspace";
+})(LegacyContentKind || (exports.LegacyContentKind = LegacyContentKind = {}));

package/dist/models/legacy/LegacyConversion.d.ts

@@ -0,0 +1,55 @@
+import { BillingPayload, TransactionPayload } from '../content/Billing';
+import { BookBody } from '../content/Book';
+import { CommentBody } from '../content/Comment';
+import { ConceptArtBody } from "../content/ConceptArt";
+import { ContentBody, ContentId } from '../content/Content';
+import { ContentKind } from '../content/ContentKind';
+import { FragmentBody } from '../content/Fragment';
+import { MediaBody } from "../content/Media";
+import { ProfileBody } from '../content/Profile';
+import { SessionBody } from '../content/Session';
+import { Stub } from '../content/Stub';
+import { CompactDateTime, MultiTime } from "../content/Time";
+import { ModernUserPayload } from "../content/User";
+import { WorkspaceBody } from '../content/Workspace';
+import { OutboundMessage } from "../OutboundMessage";
+import { LegacyComment } from './LegacyComment';
+import { LegacyContent, LegacyContentKind, LegacyDateTime, LegacyMultiTime } from './LegacyContent';
+import { LegacyFragment } from './LegacyFragment';
+import { LegacyLocator } from "./LegacyLocator";
+import { LegacyOutboundMessage } from "./LegacyOutboundMessage";
+import { LegacyPicture } from './LegacyPicture';
+import { LegacyProfile } from './LegacyProfile';
+import { LegacySession } from './LegacySession';
+import { LegacyStory } from './LegacyStory';
+import { LegacyTransaction } from './LegacyTransaction';
+import { LegacyUser } from './LegacyUser';
+import { LegacyWorkspace } from './LegacyWorkspace';
+export declare class LegacyConversion {
+    private userId;
+    constructor(userId: ContentId);
+    static convertDateTime(timestamp: LegacyDateTime): CompactDateTime;
+    static convertOutboundMessage(message: LegacyOutboundMessage): OutboundMessage;
+    convertKind(legacyKind: LegacyContentKind): ContentKind;
+    convertId(record: LegacyContent): ContentId;
+    private convertMeta;
+    convertMetaAt(legacyRecord: LegacyContent): MultiTime;
+    convertMultiTime(at: LegacyMultiTime, extraMillis: number): MultiTime;
+    private convertLegacyPayload;
+    private convertRichTextPayload;
+    convertUser(legacyUser: LegacyUser): ModernUserPayload;
+    convertBilling(legacyUser: LegacyUser, convertedTransactions: TransactionPayload[]): BillingPayload;
+    convertProfile(legacyProfile: LegacyProfile, createdAt: MultiTime, legacyAvatar: LegacyPicture): ProfileBody;
+    convertWorkspace(legacyWorkspace: LegacyWorkspace, createdAt: MultiTime, newSessionTimetsamps: MultiTime[], contentHeadStubsById?: Map<ContentId, Stub>): WorkspaceBody;
+    convertSession(legacySession: LegacySession, checkpointTable: Map<LegacyLocator, CompactDateTime>): SessionBody;
+    convertTransactionPayload(legacyTransaction: LegacyTransaction): TransactionPayload;
+    convertBook(legacyStory: LegacyStory, createdAt: MultiTime, contentHeadStubsById?: Map<ContentId, Stub>): BookBody;
+    convertCheckpoints(legacyCheckpoints: LegacyContent[]): ContentBody[];
+    convertFragment(legacyFragment: LegacyFragment, createdAt: MultiTime, isHead: boolean): FragmentBody;
+    convertPictureToMedia(legacyPicture: LegacyPicture, createdAt: MultiTime): MediaBody;
+    convertPictureToConceptArt(legacyPicture: LegacyPicture, createdAt: MultiTime, isHead: boolean): ConceptArtBody;
+    convertComment(legacyComment: LegacyComment, createdAt: MultiTime, isHead: boolean): CommentBody;
+    private convertArrayOfLocators;
+    private convertActivityArray;
+    private convertStubArray;
+}