rmapi-js 8.4.0 → 9.0.0

package/README.md

@@ -21,19 +21,28 @@ and folders ("collections"). The hash indicates the full current state to manage
 ## Usage
 
 To explore files in the cloud, you need to first register your api and persist
-the token. Then you can use `listFiles` to explore entries of different file
+the token. Then you can use `listItems` to explore entries of different file
 collections.
 
 ```ts
-import { register, remarkable } from "rmapi-js";
+import { auth, register, remarkable, session } from "rmapi-js";
 
 const code = "..."; // eight letter code from https://my.remarkable.com/device/desktop/connect
 const token = await register(code);
 // persist token so you don't have to register again
 const api = await remarkable(token);
-const fileEntries = await api.listFiles();
+const fileEntries = await api.listItems();
+
+// In stateless environments, exchange once and reuse.
+const sessionToken = await auth(token);
+const api = session(sessionToken);
+// cache `sessionToken` and reuse it across workers
 ```
 
+`auth` performs the same network call that `remarkable` does for you internally,
+returning a short-lived session token. `session` is synchronous,
+letting you construct clients from cached tokens without making a network call.
+
 To upload an epub or pdf, simply call upload with the appropriate name and buffer.
 
 ```ts
@@ -53,7 +62,7 @@ Using these apis is a little riskier since they can potentially result in data l
 // upload with custom line height not avilable through reMarkable
 await api.putEpub("name", buffer, { lineHeight: 180 })
 
-// fetch an uploaded pdf, using the hash (from listFiles)
+// fetch an uploaded pdf, using the hash (from listItems)
 const buffer = await api.getEpub(hash)
 ```
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { type BackgroundFilter, type CollectionContent, type Content, type DocumentContent, type Metadata, type Orientation, type RawRemarkableApi, type SimpleEntry, type Tag, type TemplateContent, type TextAlignment, type ZoomMode } from "./raw";
 export { HashNotFoundError, ValidationError } from "./error";
-export type { BackgroundFilter, CollectionContent, Content, CPageNumberValue, CPagePage, CPages, CPageStringValue, CPageUUID, DocumentContent, DocumentMetadata, FileType, KeyboardMetadata, Metadata, Orientation, PageTag, RawEntry, RawFileEntry, RawListEntry, RawRemarkableApi, SimpleEntry, Tag, TemplateContent, TextAlignment, UploadMimeType, ZoomMode, } from "./raw";
+export type { BackgroundFilter, CollectionContent, Content, CPageNumberValue, CPagePage, CPageStringValue, CPages, CPageUUID, DocumentContent, DocumentMetadata, Entries, FileType, KeyboardMetadata, Metadata, Orientation, PageTag, RawEntry, RawRemarkableApi, SchemaVersion, SimpleEntry, Tag, TemplateContent, TextAlignment, UploadMimeType, ZoomMode, } from "./raw";
 /** common properties shared by collections and documents */
 export interface EntryCommon {
     /** the document id, a uuid4 */
@@ -226,7 +226,7 @@ export interface RemarkableApi {
      * @remarks
      * If this fails validation and you still want to get the content, you can use
      * the low-level api to get the raw text of the `.content` file in the
-     * `RawListEntry` for this hash.
+     * `RawEntry` for this hash.
      *
      * @param hash - the hash of the item to get content for
      * @returns the content
@@ -241,7 +241,7 @@ export interface RemarkableApi {
      * @remarks
      * If this fails validation and you still want to get the content, you can use
      * the low-level api to get the raw text of the `.metadata` file in the
-     * `RawListEntry` for this hash.
+     * `RawEntry` for this hash.
      *
      * @param hash - the hash of the item to get metadata for
      * @returns the metadata
@@ -482,14 +482,17 @@ export interface RemarkableApi {
      */
     clearCache(): void;
 }
-/** options for a remarkable instance */
-export interface RemarkableOptions {
+/** configuration for exchanging a device token */
+export interface AuthOptions {
     /**
      * the url for making authorization requests
      *
      * @defaultValue "https://webapp-prod.cloud.remarkable.engineering"
      */
     authHost?: string;
+}
+/** options for constructing an api instance from a session token */
+export interface RemarkableSessionOptions {
     /**
      * the url for making synchronization requests
      *
@@ -526,14 +529,35 @@ export interface RemarkableOptions {
      */
     maxCacheSize?: number;
 }
+/** options for a remarkable instance */
+export interface RemarkableOptions extends AuthOptions, RemarkableSessionOptions {
+}
+/**
+ * Exchange a device token for a session token.
+ *
+ * @param deviceToken - the device token proving this api instance is
+ *    registered. Create one with {@link register}.
+ * @returns the session token returned by the reMarkable service
+ */
+export declare function auth(deviceToken: string, { authHost }?: AuthOptions): Promise<string>;
+/**
+ * Create an API instance from an existing session token.
+ *
+ * If requests start failing, simply recreate the api instance with a freshly
+ * fetched session token.
+ *
+ * @param sessionToken - the session token used for authorization
+ * @returns an api instance
+ */
+export declare function session(sessionToken: string, { rawHost, uploadHost, cache, maxCacheSize, }?: RemarkableSessionOptions): RemarkableApi;
 /**
  * create an instance of the api
  *
- * This gets a temporary authentication token with the device token. If
- * requests start failing, simply recreate the api instance.
+ * This gets a temporary authentication token with the device token and then
+ * constructs the api instance.
  *
  * @param deviceToken - the device token proving this api instance is
  *    registered. Create one with {@link register}.
  * @returns an api instance
  */
-export declare function remarkable(deviceToken: string, { authHost, rawHost, uploadHost, cache, maxCacheSize, }?: RemarkableOptions): Promise<RemarkableApi>;
+export declare function remarkable(deviceToken: string, options?: RemarkableOptions): Promise<RemarkableApi>;

package/dist/index.js

@@ -126,13 +126,13 @@ export async function register(code, { deviceDesc = "browser-chrome", uuid = uui
 }
 /** the implementation of that api */
 class Remarkable {
-    #userToken;
+    #sessionToken;
     /** the same cache that underlies the raw api, allowing us to modify it */
     #cache;
     raw;
     #lastHashGen;
-    constructor(userToken, rawHost, uploadHost, cache) {
-        this.#userToken = userToken;
+    constructor(sessionToken, rawHost, uploadHost, cache) {
+        this.#sessionToken = sessionToken;
         this.#cache = cache;
         this.raw = new RawRemarkable((method, url, { body, headers } = {}) => this.#authedFetch(url, { method, body, headers }), cache, rawHost, uploadHost);
     }
@@ -144,7 +144,9 @@ class Remarkable {
     }
     async #putRootHash(hash, generation) {
         try {
-            this.#lastHashGen = await this.raw.putRootHash(hash, generation);
+            const [rootHash, gen] = await this.raw.putRootHash(hash, generation);
+            const [, , schemaVersion] = this.#lastHashGen; // guaranteed to be set
+            this.#lastHashGen = [rootHash, gen, schemaVersion];
         }
         catch (ex) {
             // if we hit a generation error, invalidate our cached generation
@@ -158,7 +160,7 @@ class Remarkable {
         const resp = await fetch(url, {
             method,
             headers: {
-                Authorization: `Bearer ${this.#userToken}`,
+                Authorization: `Bearer ${this.#sessionToken}`,
                 ...headers,
             },
             // fetch works correctly with uint8 arrays, but is not hinted correctly
@@ -178,7 +180,7 @@ class Remarkable {
         }
     }
     async #convertEntry({ hash, id }) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const metaEnt = entries.find((ent) => ent.id.endsWith(".metadata"));
         const contentEnt = entries.find((ent) => ent.id.endsWith(".content"));
         if (metaEnt === undefined) {
@@ -238,11 +240,11 @@ class Remarkable {
     }
     async listIds(refresh = false) {
         const [hash] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         return entries.map(({ id, hash }) => ({ id, hash }));
     }
     async getContent(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [cont] = entries.filter((e) => e.id.endsWith(".content"));
         if (cont === undefined) {
             throw new Error(`couldn't find contents for hash ${hash}`);
@@ -252,7 +254,7 @@ class Remarkable {
         }
     }
     async getMetadata(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [meta] = entries.filter((e) => e.id.endsWith(".metadata"));
         if (meta === undefined) {
             throw new Error(`couldn't find metadata for hash ${hash}`);
@@ -262,7 +264,7 @@ class Remarkable {
         }
     }
     async getPdf(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [pdf] = entries.filter((e) => e.id.endsWith(".pdf"));
         if (pdf === undefined) {
             throw new Error(`couldn't find pdf for hash ${hash}`);
@@ -272,7 +274,7 @@ class Remarkable {
         }
     }
     async getEpub(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const [epub] = entries.filter((e) => e.id.endsWith(".epub"));
         if (epub === undefined) {
             throw new Error(`couldn't find epub for hash ${hash}`);
@@ -282,7 +284,7 @@ class Remarkable {
         }
     }
     async getDocument(hash) {
-        const entries = await this.raw.getEntries(hash);
+        const { entries } = await this.raw.getEntries(hash);
         const zip = new JSZip();
         for (const entry of entries) {
             // TODO if this is .metadata we might want to assert type === "DocumentType"
@@ -331,7 +333,7 @@ class Remarkable {
             sizeInBytes: buffer.length.toFixed(),
         };
         // upload raw files, and get root hash
-        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [pagedataEntry, uploadPagedata], [fileEntry, uploadFile], [rootHash, generation],] = await Promise.all([
+        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [pagedataEntry, uploadPagedata], [fileEntry, uploadFile], [rootHash, generation, schemaVersion],] = await Promise.all([
             this.raw.putContent(`${id}.content`, content),
             this.raw.putMetadata(`${id}.metadata`, metadata),
             // eslint-disable-next-line spellcheck/spell-checker
@@ -340,18 +342,13 @@ class Remarkable {
             this.#getRootHash(refresh),
         ]);
         // now fetch root entries and upload this file entry
-        const [[collectionEntry, uploadCollection], rootEntries] = await Promise.all([
-            this.raw.putEntries(id, [
-                contentEntry,
-                metadataEntry,
-                pagedataEntry,
-                fileEntry,
-            ]),
+        const [[collectionEntry, uploadCollection], { entries: rootEntries }] = await Promise.all([
+            this.raw.putEntries(id, [contentEntry, metadataEntry, pagedataEntry, fileEntry], schemaVersion),
             this.raw.getEntries(rootHash),
         ]);
         // now upload a new root entry
         rootEntries.push(collectionEntry);
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries, schemaVersion);
         // before updating the root hash, first upload everything
         await Promise.all([
             uploadContent,
@@ -393,19 +390,19 @@ class Remarkable {
             visibleName,
         };
         // upload folder contents
-        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [rootHash, generation],] = await Promise.all([
+        const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [rootHash, generation, schemaVersion],] = await Promise.all([
             this.raw.putContent(`${id}.content`, content),
             this.raw.putMetadata(`${id}.metadata`, metadata),
             this.#getRootHash(refresh),
         ]);
         // now fetch root entries and upload this file entry
-        const [[collectionEntry, uploadCollection], rootEntries] = await Promise.all([
-            this.raw.putEntries(id, [contentEntry, metadataEntry]),
+        const [[collectionEntry, uploadCollection], { entries: rootEntries }] = await Promise.all([
+            this.raw.putEntries(id, [contentEntry, metadataEntry], schemaVersion),
             this.raw.getEntries(rootHash),
         ]);
         // now upload a new root entry
         rootEntries.push(collectionEntry);
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", rootEntries, schemaVersion);
         // before updating the root hash, first upload everything
         await Promise.all([
             uploadContent,
@@ -430,8 +427,8 @@ class Remarkable {
         return await this.raw.uploadFile(visibleName, new Uint8Array(0), "folder");
     }
     /** edit just a content entry */
-    async #editContentRaw(id, hash, update) {
-        const entries = await this.raw.getEntries(hash);
+    async #editContentRaw(id, hash, update, schemaVersion) {
+        const { entries } = await this.raw.getEntries(hash);
         const contInd = entries.findIndex((ent) => ent.id.endsWith(".content"));
         const contEntry = entries[contInd];
         if (contEntry === undefined) {
@@ -441,28 +438,28 @@ class Remarkable {
         Object.assign(cont, update);
         const [newContEntry, uploadCont] = await this.raw.putContent(contEntry.id, cont);
         entries[contInd] = newContEntry;
-        const [result, uploadEntries] = await this.raw.putEntries(id, entries);
+        const [result, uploadEntries] = await this.raw.putEntries(id, entries, schemaVersion);
         const upload = Promise.all([uploadCont, uploadEntries]);
         return [result, upload];
     }
     /** fully sync a content edit */
     async #editContent(hash, update, expectedType, refresh) {
-        const [rootHash, generation] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(rootHash);
+        const [rootHash, generation, schemaVersion] = await this.#getRootHash(refresh);
+        const { entries } = await this.raw.getEntries(rootHash);
         const hashInd = entries.findIndex((ent) => ent.hash === hash);
         const hashEnt = entries[hashInd];
         if (hashEnt === undefined) {
             throw new HashNotFoundError(hash);
         }
         const [[newEnt, uploadEnt], meta] = await Promise.all([
-            this.#editContentRaw(hashEnt.id, hash, update),
+            this.#editContentRaw(hashEnt.id, hash, update, schemaVersion),
             this.getMetadata(hash),
         ]);
         if (meta.type !== expectedType) {
             throw new Error(`expected type ${expectedType} but got ${meta.type} for hash ${hash}`);
         }
         entries[hashInd] = newEnt;
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries, schemaVersion);
         await Promise.all([uploadEnt, uploadRoot]);
         await this.#putRootHash(rootEntry.hash, generation);
         return { hash: newEnt.hash };
@@ -479,8 +476,8 @@ class Remarkable {
     async updateTemplate(hash, content, refresh = false) {
         return await this.#editContent(hash, content, "TemplateType", refresh);
     }
-    async #editMetaRaw(id, hash, update) {
-        const entries = await this.raw.getEntries(hash);
+    async #editMetaRaw(id, hash, update, schemaVersion) {
+        const { entries } = await this.raw.getEntries(hash);
         const metaInd = entries.findIndex((ent) => ent.id.endsWith(".metadata"));
         const metaEntry = entries[metaInd];
         if (metaEntry === undefined) {
@@ -490,21 +487,21 @@ class Remarkable {
         Object.assign(meta, update);
         const [newMetaEntry, uploadMeta] = await this.raw.putMetadata(metaEntry.id, meta);
         entries[metaInd] = newMetaEntry;
-        const [result, uploadEntries] = await this.raw.putEntries(id, entries);
+        const [result, uploadEntries] = await this.raw.putEntries(id, entries, schemaVersion);
         const upload = Promise.all([uploadMeta, uploadEntries]);
         return [result, upload];
     }
     async #editMeta(hash, update, refresh = false) {
-        const [rootHash, generation] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(rootHash);
+        const [rootHash, generation, schemaVersion] = await this.#getRootHash(refresh);
+        const { entries } = await this.raw.getEntries(rootHash);
         const hashInd = entries.findIndex((ent) => ent.hash === hash);
         const hashEnt = entries[hashInd];
         if (hashEnt === undefined) {
             throw new HashNotFoundError(hash);
         }
-        const [newEnt, uploadEnt] = await this.#editMetaRaw(hashEnt.id, hash, update);
+        const [newEnt, uploadEnt] = await this.#editMetaRaw(hashEnt.id, hash, update, schemaVersion);
         entries[hashInd] = newEnt;
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", entries, schemaVersion);
         await Promise.all([uploadEnt, uploadRoot]);
         await this.#putRootHash(rootEntry.hash, generation);
         return { hash: newEnt.hash };
@@ -533,8 +530,8 @@ class Remarkable {
         if (!idReg.test(parent)) {
             throw new ValidationError(parent, idReg, "parent must be a valid document id");
         }
-        const [rootHash, generation] = await this.#getRootHash(refresh);
-        const entries = await this.raw.getEntries(rootHash);
+        const [rootHash, generation, schemaVersion] = await this.#getRootHash(refresh);
+        const { entries } = await this.raw.getEntries(rootHash);
         const hashSet = new Set(hashes);
         const toUpdate = [];
         const newEntries = [];
@@ -542,7 +539,7 @@ class Remarkable {
             const part = hashSet.has(entry.hash) ? toUpdate : newEntries;
             part.push(entry);
         }
-        const resolved = await Promise.all(toUpdate.map(({ id, hash }) => this.#editMetaRaw(id, hash, { parent })));
+        const resolved = await Promise.all(toUpdate.map(({ id, hash }) => this.#editMetaRaw(id, hash, { parent }, schemaVersion)));
         const uploads = [];
         const result = {};
         for (const [i, [newEnt, upload]] of resolved.entries()) {
@@ -550,7 +547,7 @@ class Remarkable {
             uploads.push(upload);
             result[toUpdate[i].hash] = newEnt.hash;
         }
-        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", newEntries);
+        const [rootEntry, uploadRoot] = await this.raw.putEntries("root", newEntries, schemaVersion);
         await Promise.all([Promise.all(uploads), uploadRoot]);
         await this.#putRootHash(rootEntry.hash, generation);
         return { hashes: result };
@@ -571,7 +568,8 @@ class Remarkable {
         // should only go one step) to track all hashes encountered
         // NOTE that we could increase the cache in this process, or it's possible
         // for other calls to increase the cache with misc values.
-        let entries = [await this.raw.getEntries(rootHash)];
+        const base = await this.raw.getEntries(rootHash);
+        let entries = [base.entries];
         let nextEntries = [];
         while (entries.length) {
             for (const entryList of entries) {
@@ -582,7 +580,8 @@ class Remarkable {
                     }
                 }
             }
-            entries = await Promise.all(nextEntries);
+            const resolved = await Promise.all(nextEntries);
+            entries = resolved.map((ent) => ent.entries);
             nextEntries = [];
         }
         for (const key of toDelete) {
@@ -596,16 +595,13 @@ class Remarkable {
 }
 const cached = values(nullable(string()));
 /**
- * create an instance of the api
- *
- * This gets a temporary authentication token with the device token. If
- * requests start failing, simply recreate the api instance.
+ * Exchange a device token for a session token.
  *
  * @param deviceToken - the device token proving this api instance is
  *    registered. Create one with {@link register}.
- * @returns an api instance
+ * @returns the session token returned by the reMarkable service
  */
-export async function remarkable(deviceToken, { authHost = AUTH_HOST, rawHost = RAW_HOST, uploadHost = UPLOAD_HOST, cache, maxCacheSize = Infinity, } = {}) {
+export async function auth(deviceToken, { authHost = AUTH_HOST } = {}) {
     const resp = await fetch(`${authHost}/token/json/2/user/new`, {
         method: "POST",
         headers: {
@@ -615,16 +611,46 @@ export async function remarkable(deviceToken, { authHost = AUTH_HOST, rawHost =
     if (!resp.ok) {
         throw new Error(`couldn't fetch auth token: ${resp.statusText}`);
     }
-    const userToken = await resp.text();
+    return await resp.text();
+}
+/**
+ * Create an API instance from an existing session token.
+ *
+ * If requests start failing, simply recreate the api instance with a freshly
+ * fetched session token.
+ *
+ * @param sessionToken - the session token used for authorization
+ * @returns an api instance
+ */
+export function session(sessionToken, { rawHost = RAW_HOST, uploadHost = UPLOAD_HOST, cache, maxCacheSize = Infinity, } = {}) {
     const initCache = JSON.parse(cache ?? "{}");
     if (cached.guard(initCache)) {
         const entries = Object.entries(initCache);
-        const cache = maxCacheSize === Infinity
+        const cacheMap = maxCacheSize === Infinity
             ? new Map(entries)
             : new LruCache(maxCacheSize, entries);
-        return new Remarkable(userToken, rawHost, uploadHost, cache);
-    }
-    else {
-        throw new Error("cache was not a valid cache (json string mapping); your cache must be corrupted somehow. Either initialize remarkable without a cache, or fix its format.");
+        return new Remarkable(sessionToken, rawHost, uploadHost, cacheMap);
     }
+    throw new Error("cache was not a valid cache (json string mapping); your cache must be corrupted somehow. Either initialize remarkable without a cache, or fix its format.");
+}
+/**
+ * create an instance of the api
+ *
+ * This gets a temporary authentication token with the device token and then
+ * constructs the api instance.
+ *
+ * @param deviceToken - the device token proving this api instance is
+ *    registered. Create one with {@link register}.
+ * @returns an api instance
+ */
+export async function remarkable(deviceToken, options = {}) {
+    const { authHost, rawHost, uploadHost, cache, maxCacheSize, syncHost } = options ?? {};
+    const sessionToken = await auth(deviceToken, { authHost });
+    return session(sessionToken, {
+        rawHost,
+        uploadHost,
+        cache,
+        maxCacheSize,
+        syncHost,
+    });
 }

package/dist/raw.d.ts

@@ -1,7 +1,10 @@
+import "core-js/proposals/array-buffer-base64";
 /** request types */
 export type RequestMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
 /** the supported upload mime types */
 export type UploadMimeType = "application/pdf" | "application/epub+zip" | "folder";
+/** the schema version */
+export type SchemaVersion = 3 | 4;
 /** an simple entry without any extra information */
 export interface SimpleEntry {
     /** the document id */
@@ -17,9 +20,9 @@ export interface SimpleEntry {
  * files, the high level entry will have the same hash and id as the low-level
  * entry for that collection.
  */
-export interface RawListEntry {
-    /** collection type (80000000) */
-    type: 80000000;
+export interface RawEntry {
+    /** 80000000 for schema 3 collection type or 0 for schema 4 or schema 3 files or */
+    type: 80000000 | 0;
     /** the hash of the collection this points to */
     hash: string;
     /** the unique id of the collection */
@@ -29,23 +32,21 @@ export interface RawListEntry {
     /** the total size of everything in the collection */
     size: number;
 }
-/** the low-level entry for a single file */
-export interface RawFileEntry {
-    /** file type (0) */
-    type: 0;
-    /** the hash of the file this points to */
-    hash: string;
-    /** the unique id of the file */
-    id: string;
-    /** the number of subfiles, always zero */
-    subfiles: 0;
-    /** the size of the file in bytes */
-    size: number;
-}
-/** a low-level stored entry */
-export type RawEntry = RawListEntry | RawFileEntry;
 /** the type of files reMarkable supports */
 export type FileType = "epub" | "pdf" | "notebook";
+/**
+ * a parsed entries file
+ *
+ * id and size are defined for schema 4 but not for 3
+ */
+export interface Entries {
+    /** the raw entries in the file */
+    entries: RawEntry[];
+    /** the id of this entry, only specified for schema 4 */
+    id?: string;
+    /** the recursive size of this entry, only specified for schema 4 */
+    size?: number;
+}
 /** a tag for an entry */
 export interface Tag {
     /** the name of the tag */
@@ -61,7 +62,7 @@ export interface PageTag extends Tag {
 /** all supported document orientations */
 export type Orientation = "portrait" | "landscape";
 /** all supported text alignments */
-export type TextAlignment = "justify" | "left";
+export type TextAlignment = "" | "justify" | "left";
 /** types of zoom modes for documents, applies primarily to pdf files */
 export type ZoomMode = "bestFit" | "customFit" | "fitToHeight" | "fitToWidth";
 /**
@@ -202,8 +203,8 @@ export interface DocumentContent {
     pageCount: number;
     /** the page tags for the document */
     pageTags?: PageTag[];
-    /** a list of the ids of each page in the document */
-    pages?: string[];
+    /** a list of the ids of each page in the document, or null when never opened */
+    pages?: string[] | null;
     /** a mapping from page number to page id in pages */
     redirectionPageMap?: number[];
     /** ostensibly the size in bytes of the file, but this differs from other measurements */
@@ -426,7 +427,7 @@ export interface RawRemarkableApi {
      *
      * @returns the root hash and the current generation
      */
-    getRootHash(): Promise<[string, number]>;
+    getRootHash(): Promise<[string, number, SchemaVersion]>;
     /**
      * get the raw binary data associated with a hash
      *
@@ -453,7 +454,7 @@ export interface RawRemarkableApi {
      * @param hash - the hash to get entries for
      * @returns the entries
      */
-    getEntries(hash: string): Promise<RawEntry[]>;
+    getEntries(hash: string): Promise<Entries>;
     /**
      * get the parsed and validated `Content` of a content hash
      *
@@ -508,13 +509,13 @@ export interface RawRemarkableApi {
      * @param bytes - the bytes to upload
      * @returns the new entry and a promise to finish the upload
      */
-    putFile(id: string, bytes: Uint8Array): Promise<[RawFileEntry, Promise<void>]>;
+    putFile(id: string, bytes: Uint8Array): Promise<[RawEntry, Promise<void>]>;
     /** the same as {@link putFile | `putFile`} but with caching for text */
-    putText(id: string, content: string): Promise<[RawFileEntry, Promise<void>]>;
+    putText(id: string, content: string): Promise<[RawEntry, Promise<void>]>;
     /** the same as {@link putText | `putText`} but with extra validation for Content */
-    putContent(id: string, content: Content): Promise<[RawFileEntry, Promise<void>]>;
+    putContent(id: string, content: Content): Promise<[RawEntry, Promise<void>]>;
     /** the same as {@link putText | `putText`} but with extra validation for Metadata */
-    putMetadata(id: string, metadata: Metadata): Promise<[RawFileEntry, Promise<void>]>;
+    putMetadata(id: string, metadata: Metadata): Promise<[RawEntry, Promise<void>]>;
     /**
      * put a set of entries to make an entry list file
      *
@@ -530,7 +531,7 @@ export interface RawRemarkableApi {
      *
      * @returns the new list entry and a promise to finish the upload
      */
-    putEntries(id: string, entries: RawEntry[]): Promise<[RawListEntry, Promise<void>]>;
+    putEntries(id: string, entries: RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
     /**
      * upload a file to the reMarkable cloud using the simple api
      *
@@ -554,28 +555,26 @@ export interface RawRemarkableApi {
     /** completely clear the cache */
     clearCache(): void;
 }
-interface AuthedFetch {
-    (method: RequestMethod, url: string, init?: {
-        body?: string | Uint8Array;
-        headers?: Record<string, string>;
-    }): Promise<Response>;
-}
+type AuthedFetch = (method: RequestMethod, url: string, init?: {
+    body?: string | Uint8Array;
+    headers?: Record<string, string>;
+}) => Promise<Response>;
 export declare class RawRemarkable implements RawRemarkableApi {
     #private;
     constructor(authedFetch: AuthedFetch, cache: Map<string, string | null>, rawHost: string, uploadHost: string);
     /** make an authorized request to remarkable */
-    getRootHash(): Promise<[string, number]>;
+    getRootHash(): Promise<[string, number, SchemaVersion]>;
     getHash(hash: string): Promise<Uint8Array>;
     getText(hash: string): Promise<string>;
-    getEntries(hash: string): Promise<RawEntry[]>;
+    getEntries(hash: string): Promise<Entries>;
     getContent(hash: string): Promise<Content>;
     getMetadata(hash: string): Promise<Metadata>;
     putRootHash(hash: string, generation: number, broadcast?: boolean): Promise<[string, number]>;
-    putFile(id: string, bytes: Uint8Array): Promise<[RawFileEntry, Promise<void>]>;
-    putText(id: string, text: string): Promise<[RawFileEntry, Promise<void>]>;
-    putContent(id: string, content: Content): Promise<[RawFileEntry, Promise<void>]>;
-    putMetadata(id: string, metadata: Metadata): Promise<[RawFileEntry, Promise<void>]>;
-    putEntries(id: string, entries: RawEntry[]): Promise<[RawListEntry, Promise<void>]>;
+    putFile(id: string, bytes: Uint8Array): Promise<[RawEntry, Promise<void>]>;
+    putText(id: string, text: string): Promise<[RawEntry, Promise<void>]>;
+    putContent(id: string, content: Content): Promise<[RawEntry, Promise<void>]>;
+    putMetadata(id: string, metadata: Metadata): Promise<[RawEntry, Promise<void>]>;
+    putEntries(id: string, entries: RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
     uploadFile(visibleName: string, bytes: Uint8Array, mime: UploadMimeType): Promise<SimpleEntry>;
     dumpCache(): string;
     clearCache(): void;