rmapi-js 5.0.0 → 7.0.0

package/dist/index.d.ts

@@ -1,240 +1,134 @@
 /** request types */
-export type RequestMethod = "POST" | "GET" | "PUT" | "DELETE";
-/** text alignment types */
+export type RequestMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
+/** a tag for an entry */
+export interface Tag {
+    /** the name of the tag */
+    name: string;
+    /** the timestamp when this tag was added */
+    timestamp: number;
+}
+/** a tag for individual pages */
+export interface PageTag extends Tag {
+    /** the id of the page this is on */
+    pageId: string;
+}
+/** the type of files reMarkable supports */
+export type FileType = "epub" | "pdf" | "notebook";
+/** all supported document orientations */
+export type Orientation = "portrait" | "landscape";
+/** all supported text alignments */
 export type TextAlignment = "justify" | "left";
-/** tool options */
-export declare const builtinTools: readonly ["Ballpoint", "Ballpointv2", "Brush", "Calligraphy", "ClearPage", "EraseSection", "Eraser", "Fineliner", "Finelinerv2", "Highlighter", "Highlighterv2", "Marker", "Markerv2", "Paintbrush", "Paintbrushv2", "Pencilv2", "SharpPencil", "SharpPencilv2", "SolidPen", "ZoomTool"];
-/** font name options */
-export declare const builtinFontNames: readonly ["Maison Neue", "EB Garamond", "Noto Sans", "Noto Serif", "Noto Mono", "Noto Sans UI"];
-/** text scale options */
-export declare const builtinTextScales: {
-    /** the smallest */
-    readonly xs: 0.7;
-    /** small */
-    readonly sm: 0.8;
-    /** medium / default */
-    readonly md: 1;
-    /** large */
-    readonly lg: 1.2;
-    /** extra large */
-    readonly xl: 1.5;
-    /** double extra large */
-    readonly xx: 2;
-};
-/** margin options */
-export declare const builtinMargins: {
-    /** small */
-    readonly sm: 50;
-    /** medium */
-    readonly md: 125;
-    /** default for read on remarkable */
-    readonly rr: 180;
-    /** large */
-    readonly lg: 200;
-};
-/** line height options */
-export declare const builtinLineHeights: {
-    /** default */
-    readonly df: -1;
-    /** normal */
-    readonly md: 100;
-    /** half */
-    readonly lg: 150;
-    /** double */
-    readonly xl: 200;
-};
-/** a remarkable entry for a cloud collection */
-export interface CollectionEntry {
-    /** collection type */
-    type: "80000000";
+/** types of zoom modes for documents, applies primarily to pdf files */
+export type ZoomMode = "bestFit" | "customFit" | "fitToHeight" | "fitToWidth";
+/**
+ * types of background filter
+ *
+ * off has no background filter, best for images, full page applies the high
+ * contrast filter to the entire page. If this is omitted, reMarkable will try
+ * to apply the filter only to text areas.
+ */
+export type BackgroundFilter = "off" | "fullpage";
+/**
+ * the low-level entry corresponding to a collection of files
+ *
+ * A collection could be for the root collection, or for an individual document,
+ * which is often a collection of files. If an entry represents a collection of
+ * 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;
     /** the hash of the collection this points to */
     hash: string;
     /** the unique id of the collection */
-    documentId: string;
+    id: string;
     /** the number of subfiles */
     subfiles: number;
-    /** collections don't have sizes */
-    size: bigint;
+    /** the total size of everything in the collection */
+    size: number;
 }
-/** a remarkable entry for cloud data */
-export interface FileEntry {
-    /** file type */
-    type: "0";
+/** 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 */
-    documentId: string;
-    /** files don't have subfiles */
+    id: string;
+    /** the number of subfiles, always zero */
     subfiles: 0;
-    /** size of the file */
-    size: bigint;
+    /** the size of the file in bytes */
+    size: number;
 }
-/** a remarkable entry for cloud items */
-export type Entry = CollectionEntry | FileEntry;
-/** an simple entry produced by the upload api */
-export interface UploadEntry {
-    /** the document id */
-    docID: string;
-    /** the document hash */
+/** a low-level stored entry */
+export type RawEntry = RawListEntry | RawFileEntry;
+/** common properties shared by collections and documents */
+export interface EntryCommon {
+    /** the document id, a uuid4 */
+    id: string;
+    /** the current hash of the state of this entry */
     hash: string;
-}
-/** common metadata for documents and collections */
-export interface CommonMetadata {
-    /** name of content */
+    /** the visible display name of this entry */
     visibleName: string;
-    /** parent uuid (documentId) or "" for root or "trash" */
+    /** the last modified timestamp */
+    lastModified: string;
+    /** true if the entry is starred in most ui elements */
+    pinned: boolean;
+    /**
+     * the parent of this entry
+     *
+     * There are two special parents, "" (empty string) for the root directory,
+     * and "trash" for the trash
+     */
     parent?: string;
-    /** last modified time */
-    lastModified?: string;
-    /** unknown significance */
-    version?: number;
-    /** unknown significance */
-    pinned?: boolean;
-    /** unknown significance */
-    synced?: boolean;
-    /** unknown significance */
-    modified?: boolean;
-    /** if file is deleted */
-    deleted?: boolean;
-    /** unknown significance */
-    metadatamodified?: boolean;
+    /** any tags the entry might have */
+    tags?: Tag[];
 }
-/** metadata for collection types */
-export interface CollectionTypeMetadata extends CommonMetadata {
-    /** the key for collection types */
+/** a folder, referred to in the api as a collection */
+export interface CollectionEntry extends EntryCommon {
+    /** the key for this as a collection */
     type: "CollectionType";
 }
-/** metadata for document types */
-export interface DocumentTypeMetadata extends CommonMetadata {
-    /** the key for document types */
+/** a file, referred to in the api as a document */
+export interface DocumentType extends EntryCommon {
+    /** the key to identify this as a document */
     type: "DocumentType";
-    /** last opened time for documents */
-    lastOpened?: string;
-    /** last opened page for documents */
-    lastOpenedPage?: number;
-    /** created time */
-    createdTime?: string;
+    /** the type of the file */
+    fileType: "epub" | "pdf" | "notebook";
+    /** the timestamp of the last time this entry was opened */
+    lastOpened: string;
 }
-/**
- * metadata for a document or collection (folder)
- *
- * This is found in the the `.metadata` file.
- */
-export type Metadata = CollectionTypeMetadata | DocumentTypeMetadata;
-/** fields common to all {@link MetadataEntry | MetadataEntries} */
-export interface BaseMetadataEntry {
-    /** the document id of the entry */
+/** a remarkable entry for cloud items */
+export type Entry = CollectionEntry | DocumentType;
+/** an simple entry without any extra information */
+export interface SimpleEntry {
+    /** the document id */
     id: string;
-    /** the hash of the entry */
+    /** the document hash */
     hash: string;
 }
-/** the metadata entry for a collection */
-export interface CollectionMetadataEntry extends BaseMetadataEntry, CollectionTypeMetadata {
+/** the new hash of a modified entry */
+export interface HashEntry {
+    /** the actual hash */
+    hash: string;
 }
-/** the metadata entry for a document */
-export interface DocumentMetadataEntry extends BaseMetadataEntry, DocumentTypeMetadata {
-    /** the type of the document */
-    fileType: FileType;
+/** the mapping from old hashes to new hashes after a bulk modify */
+export interface HashesEntry {
+    /** the mapping from old to new hashes */
+    hashes: Record<string, string>;
 }
-/** a full metadata entry returned by {@link RemarkableApi.getEntriesMetadata} */
-export type MetadataEntry = CollectionMetadataEntry | DocumentMetadataEntry;
-/** extra content metadata */
-export type ExtraMetadata = Record<string, string | undefined>;
-/** remarkable file type; empty for notebook */
-export type FileType = "notebook" | "pdf" | "epub" | "";
-/** document matrix transform */
-export type Transform = Record<`m${1 | 2 | 3}${1 | 2 | 3}`, number>;
-/** content document metadata */
-export interface DocumentMetadata {
-    /** document title */
-    title?: string;
-    /** document authors */
-    authors?: string[];
-}
-/**
- * content metadata
+/** An error that gets thrown when the backend while trying to update
+ *
+ * IF you encounter this error, you likely just need to try th request again. If
+ * you're trying to do several high-level `put` operations simultaneously,
+ * you'll likely encounter this error. You should either try to do them
+ * serially, or call the low level api directly to do one generation update.
  *
- * This is found in the `.content` file.
+ * @see {@link RawRemarkableApi | `RawRemarkableApi`}
  */
-export interface Content {
-    /** is this a dummy document */
-    dummyDocument: boolean;
-    /** document metadata */
-    documentMetadata?: DocumentMetadata;
-    /** extra metadata */
-    extraMetadata: ExtraMetadata;
-    /** file type */
-    fileType: FileType;
-    /** font */
-    fontName?: string;
-    /** last opened page */
-    lastOpenedPage: number;
-    /** line height */
-    lineHeight: number;
-    /** page margins in points */
-    margins: number;
-    /** orientation */
-    orientation?: "portrait" | "landscape";
-    /** number of pages */
-    pageCount: number;
-    /** page ids */
-    pages: string[];
-    /** number to use for the coverage page, -1 for last opened */
-    coverPageNumber: number;
-    /** text scale */
-    textScale: number;
-    /** page transform */
-    transform?: Transform;
-    /** format version */
-    formatVersion: number;
-    /** text alignment */
-    textAlignment?: TextAlignment;
-}
-/** stripped down version of RequestInit */
-export interface RequestInitLike {
-    /** request method */
-    readonly method?: RequestMethod | undefined;
-    /** request headers */
-    readonly headers?: Record<string, string>;
-    /** request body */
-    readonly body?: ArrayBuffer | string;
-}
-/** stripped down version of Headers */
-export interface HeadersLike {
-    /** get a specific header value */
-    get(key: string): string | null;
-}
-/** stripped down version of Response */
-export interface ResponseLike {
-    /** true if request was successful */
-    ok: boolean;
-    /** http status */
-    status: number;
-    /** text associated with status */
-    statusText: string;
-    /** headers in response */
-    headers: HeadersLike;
-    /** get response body as text */
-    text(): Promise<string>;
-    /** get response body as an array buffer */
-    arrayBuffer(): Promise<ArrayBuffer>;
-}
-/** stripped down version of fetch */
-export interface FetchLike {
-    /** the rough interface to fetch */
-    (url: string, options?: RequestInitLike | undefined): Promise<ResponseLike>;
-}
-/** async storage, map like */
-export interface CacheLike {
-    /** get value for key or undefined if missing */
-    get(key: string): Promise<string | undefined>;
-    /** set value for key */
-    set(key: string, value: string): Promise<void>;
-}
-/** stripped down version of subtle crypto */
-export interface SubtleCryptoLike {
-    /** a digest function */
-    digest(algorithm: "SHA-256", data: BufferSource): Promise<ArrayBuffer>;
+export declare class GenerationError extends Error {
+    constructor();
 }
 /** an error that results from a failed request */
 export declare class ResponseError extends Error {
@@ -244,14 +138,13 @@ export declare class ResponseError extends Error {
     readonly statusText: string;
     constructor(status: number, statusText: string, message: string);
 }
-/**
- * an error that results from trying yp update the wrong generation.
- *
- * If we try to update the root hash of files, but the generation has changed
- * relative to the one we're updating from, this will fail.
- */
-export declare class GenerationError extends Error {
-    constructor();
+/** an error that results from a failed request */
+export declare class ValidationError extends Error {
+    /** the response status number */
+    readonly field: string;
+    /** the response status text */
+    readonly regex: RegExp;
+    constructor(field: string, regex: RegExp, message: string);
 }
 /** options for registering with the api */
 export interface RegisterOptions {
@@ -268,8 +161,6 @@ export interface RegisterOptions {
     uuid?: string;
     /** The host to use for authorization requests */
     authHost?: string;
-    /** a function for making fetch requests, see {@link RemarkableOptions.fetch} for more info */
-    fetch?: FetchLike;
 }
 /**
  * register a device and get the token needed to access the api
@@ -281,312 +172,616 @@ export interface RegisterOptions {
  * @param code - the eight letter code a user got from `https://my.remarkable.com/device/browser/connect`.
  * @returns the device token necessary for creating an api instace. These never expire so persist as long as necessary.
  */
-export declare function register(code: string, { deviceDesc, uuid, authHost, fetch, }?: RegisterOptions): Promise<string>;
-/** options for uploading an epub document */
-export interface PutEpubOptions {
-    /** the parent id, default to root */
-    parent?: string | undefined;
-    /** the margins of the epub 180 is good for articles, 125 for books */
-    margins?: number | keyof typeof builtinMargins | undefined;
-    /** the height of lines */
-    lineHeight?: number | keyof typeof builtinLineHeights | undefined;
-    /** the scale of text */
-    textScale?: number | keyof typeof builtinTextScales | undefined;
-    /** the page orientation */
-    orientation?: "portrait" | "landscape" | undefined;
-    /** the text alignment */
-    textAlignment?: TextAlignment | undefined;
-    /** which page should be shone as the cover */
-    cover?: "first" | "visited" | undefined;
-    /** the font name, should probably come from `builtinFontNames` */
-    fontName?: string | undefined;
-    /** the tool to have enabled by default */
-    lastTool?: string;
+export declare function register(code: string, { deviceDesc, uuid, authHost, }?: RegisterOptions): Promise<string>;
+/** options available when uploading a document */
+export interface UploadOptions {
+    /** an optional parent id to set when uploading */
+    parent?: string;
+}
+/** document metadata stored in {@link Content} */
+export interface DocumentMetadata {
+    /** a list of authors as a string */
+    authors?: string[];
+    /** the title as a string */
+    title?: string;
+    /** the publication date as an ISO date or timestamp */
+    publicationDate?: string;
+    /** the publisher */
+    publisher?: string;
+}
+/** [speculative] metadata stored about keyboard interactions */
+export interface KeyboardMetadata {
+    /** [unknown] */
+    count: number;
+    /** [unknown] */
+    timestamp: number;
+}
+/** a c-page value who's type is a string */
+export interface CPageStringValue {
+    /** a pseudo-timestamp of the form "1:1" or "1:2" */
+    timestamp: string;
+    /** the stored value */
+    value: string;
+}
+/** a c-page value who's type is a string */
+export interface CPageNumberValue {
+    /** a pseudo-timestamp of the form "1:1" or "1:2" */
+    timestamp: string;
+    /** the stored value */
+    value: number;
+}
+/** [speculative] information about an individual page */
+export interface CPagePage {
+    /** [speculative] the page id */
+    id: string;
+    /** [unknown] values are like "aa", "ab", "ba", etc. */
+    idx: CPageStringValue;
+    /** [unknown] */
+    redir?: CPageNumberValue;
+    /** [speculative] the template name of the page */
+    template?: CPageStringValue;
+    /** [unknown] the value is a timestamp */
+    scrollTime?: CPageStringValue;
+    /** [unknown] */
+    verticalScroll?: CPageNumberValue;
+    /** [unknown] */
+    deleted?: CPageNumberValue;
+}
+/** [unknown] */
+export interface CPageUUID {
+    /** [unknown] */
+    first: string;
+    /** [unknown] */
+    second: number;
+}
+/** [unknown] metadata about pages */
+export interface CPages {
+    /** [speculative] the last time the document was opened */
+    lastOpened: CPageStringValue;
+    /** [unknown] */
+    original: CPageNumberValue;
+    /** [speculative] information about individual pages */
+    pages: CPagePage[];
+    /** [unknown] */
+    uuids: CPageUUID[];
+}
+/** the content metadata for collections (folders) */
+export interface CollectionContent {
+    /** the tags for the collection */
+    tags?: Tag[];
+    /** collections don't have a file type */
+    fileType?: undefined;
 }
 /**
- * options for {@link RemarkableApi.getRootHash | `getRootHash`}
+ * content metadata, stored with the "content" extension
+ *
+ * This largely contains description of how to render the document, rather than
+ * metadata about it.
  */
-export interface GetRootHashOptions {
+export interface DocumentContent {
     /**
-     * whether to use the last known valid root hash
+     * which page to use for the thumbnail
      *
-     * @defaultValue true
+     * -1 indicates the last visited page, whereas 0 is the first page.
      */
-    cache?: boolean;
-}
-/**
- * options for {@link RemarkableApi.create | `create`} and
- * {@link RemarkableApi.move | `move`}
- */
-export interface CreateMoveOptions {
+    coverPageNumber: number;
+    /** metadata about the author, publishers, etc. */
+    documentMetadata: DocumentMetadata;
+    /** It's not known what this field is for */
+    dummyDocument?: boolean;
+    /** the largely contains metadata about what pens were used and their settings */
+    extraMetadata: Record<string, string>;
+    /** the underlying file type of this document */
+    fileType: FileType;
+    /**
+     * the name of the font to use for text rendering
+     *
+     * The reMarkable supports five fonts by default: "Noto Sans", "Noto Sans UI",
+     * "EB Garamond", "Noto Mono", and "Noto Serif". You can also set the font to
+     * the empty string or omit it for the default.
+     */
+    fontName: string;
+    /** the format version, this should always be 1 */
+    formatVersion: number;
+    /** the last opened page, starts at zero */
+    lastOpenedPage?: number;
     /**
-     * whether to use the last known valid root hash
+     * the line height
      *
-     * @defaultValue true
+     * The reMarkable uses three built-in line heights: 100, 150, 200, and
+     * uses -1 to indicate the default line height, but heights outside of these
+     * also work.
      */
-    cache?: boolean;
+    lineHeight: number;
     /**
-     * whether broadcast syncing complete to other devices
+     * the document margin in pixels
      *
-     * @defaultValue true
+     * The reMarkable uses three built-in margins: 50, 125, 200, but other margins
+     * are possible. The reMarkable used to default to margins of 180.
      */
-    sync?: boolean;
-}
-/** options for uploading a pdf */
-export interface PutPdfOptions {
-    /** the parent id, default to root */
-    parent?: string | undefined;
-    /** the page orientation */
-    orientation?: "portrait" | "landscape" | undefined;
-    /** which page should be shone as the cover */
-    cover?: "first" | "visited" | undefined;
-    /** the tool to have enabled by default */
-    lastTool?: string;
+    margins: number;
+    /** the document orientation */
+    orientation: Orientation;
+    /** this specifies the number of pages, it's not clear how this is different than pageCount */
+    originalPageCount?: number;
+    /** the number of pages */
+    pageCount: number;
+    /** the page tags for the document */
+    pageTags?: PageTag[];
+    /** a list of the ids of each page in the document */
+    pages?: string[];
+    /** 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 */
+    sizeInBytes: string;
+    /** document tags for this document */
+    tags?: Tag[];
+    /** text alignment for this document */
+    textAlignment: TextAlignment;
+    /**
+     * the font size
+     *
+     * reMarkable uses six built-in text scales: 0.7, 0.8, 1, 1.2, 1.5, 2, but
+     * values outside of this range are valid.
+     */
+    textScale: number;
+    /** [speculative] the center of the zoom for zoomed in documents */
+    customZoomCenterX?: number;
+    /** [speculative] the center of the zoom for zoomed in documents */
+    customZoomCenterY?: number;
+    /** [speculative] the orientation */
+    customZoomOrientation?: Orientation;
+    /** [speculative] the zoom height for zoomed in pages */
+    customZoomPageHeight?: number;
+    /** [speculative] the zoom width for zoomed in pages */
+    customZoomPageWidth?: number;
+    /** [speculative] the scale for zoomed in pages */
+    customZoomScale?: number;
+    /** what zoom mode is set for the page */
+    zoomMode?: ZoomMode;
+    /** [speculative] a transform matrix, a. la. css matrix transform */
+    transform?: Record<`m${"1" | "2" | "3"}${"1" | "2" | "3"}`, number>;
+    /** [speculative] metadata about keyboard use */
+    keyboardMetadata?: KeyboardMetadata;
+    /** [speculative] various other page metadata */
+    cPages?: CPages;
+    /**
+     * setting for the adaptive contrast filter
+     *
+     * off has no background filter, best for images, full page applies the high
+     * contrast filter to the entire page. If this is omitted, reMarkable will try
+     * to apply the filter only to text areas.
+     */
+    viewBackgroundFilter?: BackgroundFilter;
 }
-/** options for getting responses */
-export interface GetOptions {
+/** content metadata for any item */
+export type Content = CollectionContent | DocumentContent;
+/**
+ * item level metadata
+ *
+ * Stored with the extension "metadata".
+ */
+export interface Metadata {
+    /** creation time, a string of the epoch timestamp */
+    createdTime?: string;
+    /** [speculative] true if the item has been actually deleted */
+    deleted?: boolean;
+    /** the last modify time, the string of the epoch timestamp */
+    lastModified: string;
+    /** the last opened epoch timestamp, isn't defined for CollectionType */
+    lastOpened?: string;
+    /** the last page opened, isn't defined for CollectionType, starts at 0*/
+    lastOpenedPage?: number;
+    /** [speculative] true if the metadata has been modified */
+    metadatamodified?: boolean;
+    /** [speculative] true if the item has been modified */
+    modified?: boolean;
     /**
-     * whether to verify the types of the response
+     * the id of the parent collection
      *
-     * Omitting will make the results always work, but they might nit return
-     * accurate types anymore.
+     * This is the empty string for root (no parent), "trash" if it's in the
+     * trash, or the id of the parent.
      */
-    verify?: boolean | undefined;
+    parent: string;
+    /** true of the item is starred */
+    pinned: boolean;
+    /** [unknown] */
+    synced?: boolean;
+    /**
+     * the type of item this corresponds to
+     *
+     * DocumentType is a document, an epub, pdf, or notebook, CollectionType is a
+     * folder.
+     */
+    type: "DocumentType" | "CollectionType";
+    /** [speculative] metadata version, always 0 */
+    version?: number;
+    /** the visible name of the item, what it's called on the reMarkable */
+    visibleName: string;
 }
 /**
- * the api for accessing remarkable functions
+ * options for putting a file onto reMarkable
+ *
+ * This is a more customizable version of the options available when using the
+ * simpler upload api. This comes with the risk that is uses lower level apis,
+ * and therefore has more failure points.
+ *
+ * @see {@link Content | `Content`} and {@link Metadata | `Metadata`} for more
+ * information on what these fields correspond to
  */
-export interface RemarkableApi {
+export interface PutOptions {
     /**
-     * get the root hash and the current generation
+     * the collection to put this in
      *
-     * If this hasn't changed, then neither have any of the files.
+     * The empty string ("") (default) is the root, "trash" is in the trash,
+     * otherwise this should be the uuid of a collection item to place this in.
      */
-    getRootHash(options?: GetRootHashOptions): Promise<[string, bigint]>;
+    parent?: string;
+    /** true to star the item */
+    pinned?: boolean;
+    /** 0 for first page, -1 for last visited */
+    coverPageNumber?: number;
+    /** document metadata authors */
+    authors?: string[];
+    /** document metadata tile, NOTE this is not visibleName */
+    title?: string;
+    /** the publication date, as an ISO date or timestamp */
+    publicationDate?: string;
+    /** the publisher */
+    publisher?: string;
+    /** extra metadata often in the form of pen choices */
+    extraMetadata?: Record<string, string>;
+    /** the font to use for rendering */
+    fontName?: string;
+    /** the line height to render */
+    lineHeight?: number;
+    /** the margins to render */
+    margins?: number;
+    /** the document orientation */
+    orientation?: Orientation;
+    /** the names of the tags to add */
+    tags?: string[];
+    /** the document text alignment */
+    textAlignment?: TextAlignment;
+    /** the text scale of the document */
+    textScale?: number;
+    /** the document zoom mode */
+    zoomMode?: ZoomMode;
+    /** the contrast filter setting */
+    viewBackgroundFilter?: BackgroundFilter;
     /**
-     * write the root hash, incrimenting from the current generation
+     * whether to refresh current file structure before putting
      *
-     * This will fail if the current generation isn't equal to the passed in
-     * generation. Use this to preven race conditions. If this rejects, refetch
-     * the root hash, resync the updates, and then try to put again.
+     * If you suspect that other changes have been made to the remarkable backend
+     * between the last put and now, setting this to true will avoid a
+     * {@link GenerationError | `GenerationError`}, but will cause an unnecessary
+     * GET request otherwise.
+     */
+    refresh?: boolean;
+}
+/**
+ * access to the low-level reMarkable api
+ *
+ * This class gives more granualar access to the reMarkable cloud, but is more
+ * dangerous.
+ *
+ * ## Overview
+ *
+ * reMarkable uses an immutable file system, where each file is referenced by
+ * the 32 byte sha256 hash of its contents. Each file also has an id used to
+ * keep track of updates, so to "update" a file, you upload a new file, and
+ * change the hash associated with it's id.
+ *
+ * Each "item" (a document or a collection) is actually a list of files.
+ * The whole reMarkable state is then a list of these lists. Finally, the hash
+ * of that list is called the rootHash. To update anything, you have to update
+ * the root hash to point to a new list of updated items.
+ *
+ * This can be dangerous, as corrupting the root hash can destroy all of your
+ * files. It is therefore highly recommended to save your current root hash
+ * ({@link getRootHash | `getRootHash`}) before using this api to attempt file
+ * writes, so you can recover a previous "snapshot" should anything go wrong.
+ *
+ * ## Items
+ *
+ * Each item is a collection of individual files. Using
+ * {@link getEntries | `getEntries`} on the root hash will give you a list
+ * entries that correspond to items. Using `getEntries` on any of those items
+ * will get you the files that make up that item.
+ *
+ * The documented files are:
+ * - `<docid>.pdf` - a raw pdf document
+ * - `<docid>.epub` - a raw epub document
+ * - `<docid>.content` - a json file roughly describing document properties (see {@link DocumentContent | `DocumentContent`})
+ * - `<docid>.metadata` - metadata about the document (see {@link Metadata | `Metadata`})
+ * - `<docid>.pagedata` - a text file where each line is the template of that page
+ * - `<docid>/<pageid>.rm` - [speculative] raw remarkable vectors, text, etc
+ * - `<docid>/<pageid>-metadata.json` - [speculative] metadata about the individual page
+ * - `<docid>.highlights/<pageid>.json` - [speculative] highlights on the page
+ *
+ * Some items will have both a `.pdf` and `.epub` file, likely due to preparing
+ * for export. Collections only have `.content` and `.metadata` files, with
+ * `.content` only containing tags.
+ *
+ * ## Caching
+ *
+ * Since everything is tied to the hash of it's contents, we can agressively
+ * cache results. We assume that text contents are "small" and so fully cache
+ * them, where as binary files we treat as large and only store that we know
+ * they exist to prevent future writes.
+ *
+ * By default, this only persists as long as the api instance is alive. However,
+ * for performance reasons, you should call {@link dumpCache | `dumpCache`} to
+ * persist the cache between sessions.
+ *
+ * @remarks
+ *
+ * Generally all hashes are 64 character hex strings, and all ids are uuid4.
+ */
+export interface RawRemarkableApi {
+    /**
+     * gets the root hash and the current generation
      *
-     * @remarks Updating the root hash can be dangerous as it changes the full
-     * state of what's on the the remarkable. However, it's also the only way to
-     * change what's actually visible. If you're unsure if you're doing the right
-     * thing, make sure to first save your inital root hash. Then you can always
-     * recover by doing:
-     * ```
-     * let [, gen] = await api.getRootHash();
-     * await api.putRootHash(backup, gen);
-     * ```
+     * When calling `putRootHash`, you should pass the generation you got from
+     * this call. That way you tell reMarkable you're updating the previous state.
      *
-     * @param hash - the hash of the new root collection
-     * @param generation - the current generation this builds off of
-     * @returns the new generation
-     * @throws {@link GenerationError} if the current cloud generation didn't
-     * match the expected pushed generation.
+     * @returns the root hash and the current generation
      */
-    putRootHash(hash: string, generation: bigint): Promise<bigint>;
+    getRootHash(): Promise<[string, number]>;
     /**
-     * get array buffer associated with a hash
+     * get the raw binary data associated with a hash
      *
-     * @param hash - the hash to get text data from
+     * @param hash - the hash to get the data for
+     * @returns the data
      */
-    getBuffer(hash: string): Promise<ArrayBuffer>;
+    getHash(hash: string): Promise<Uint8Array>;
     /**
-     * get text content associated with hash
+     * get raw text data associated with a hash
      *
-     * @param hash - the hash to get text data from
+     * We assume text data are small, and so cache the entire text. If you want to
+     * avoid this, use {@link getHash | `getHash`} combined with a TextDecoder.
+  
+     * @param hash - the hash to get text for
+     * @returns the text
      */
     getText(hash: string): Promise<string>;
     /**
-     * get a json object associated with a hash
+     * get the entries associated with a list hash
      *
-     * This is identical to `getText(hash).then(JSON.parse)` and is only provided
-     * for consistency with {@link RemarkableApi.putJson | `putJson`}.
+     * A list hash is the root hash, or any hash with the type 80000000. NOTE
+     * these are hashed differently than files.
+  
+     * @param hash - the hash to get entries for
+     * @returns the entries
      */
-    getJson(hash: string): Promise<unknown>;
-    /** get metadata from hash */
-    getMetadata(hash: string, opts?: GetOptions): Promise<Metadata>;
+    getEntries(hash: string): Promise<RawEntry[]>;
     /**
-     * get entries from a collection hash
+     * get the parsed and validated `Content` of a content hash
      *
-     * If omitted, this will use `getRootHash()`.
+     * Use {@link getText | `getText`} combined with `JSON.parse` to bypass
+     * validation
+  
+     * @param hash - the hash to get Content for
+     * @returns the content
      */
-    getEntries(hash?: string): Promise<Entry[]>;
-    /** put a reference to a set of entries into the cloud */
-    putEntries(documentId: string, entries: Entry[]): Promise<CollectionEntry>;
-    /** put a raw buffer in the cloud */
-    putBuffer(documentId: string, buffer: ArrayBuffer): Promise<FileEntry>;
+    getContent(hash: string): Promise<Content>;
     /**
-     * put a raw text in the cloud encoded as utf-8
+     * get the parsed and validated `Metadata` of a metadata hash
      *
-     * this is no different than using `putBuffer(..., new TextEncoder().encode(contents))`
+     * Use {@link getText | `getText`} combined with `JSON.parse` to bypass
+     * validation
+  
+     * @param hash - the hash to get Metadata for
+     * @returns the metadata
      */
-    putText(documentId: string, contents: string): Promise<FileEntry>;
+    getMetadata(hash: string): Promise<Metadata>;
     /**
-     * put json into the cloud
-     *
-     * This uses a stable (sorted keys) json serilization to preserve consistent
-     * hashes.
+     * update the current root hash
+     *
+     * This will fail if generation doesn't match the current server generation.
+     * This ensures that you are updating what you expect. IF you get a
+     * {@link GenerationError | `GenerationError`}, that indicates that the server
+     * was updated after you last got the generation. You should call
+     * {@link getRootHash | `getRootHash`} and then recompute the changes you want
+     * from the new root hash. If you ignore the update hash value and just call
+     * `putRootHash` again, you will overwrite the changes made by the other
+     * update.
+     *
+     * @param hash - the new root hash
+     * @param generation - the generation of the current root hash
+     * @param broadcast - [unknown] an option in the request
+     *
+     * @throws GenerationError if the generation doesn't match the current server generation
+     * @returns the new root hash and the new generation
      */
-    putJson(documentId: string, contents: object): Promise<FileEntry>;
+    putRootHash(hash: string, generation: number, broadcast?: boolean): Promise<[string, number]>;
     /**
-     * put metadata into the cloud
+     * put a raw onto the server
+     *
+     * This returns the new expeced entry of the file you uploaded, and a promise
+     * to finish the upload successful. By splitting these two operations you can
+     * start using the uploaded entry while file finishes uploading.
      *
-     * This is a small wrapper around {@link RemarkableApi.putText | `putText`}.
+     * NOTE: This won't update the state of the reMarkable until this entry is
+     * incorporated into the root hash.
      *
-     * @param documentId - this should be the documentId of the item that this is
-     *   metadata for; it should not end in `.metadata`
-     * @param metadata - the metadata to upload
+     * @param id - the id of the file to upload
+     * @param bytes - the bytes to upload
+     * @returns the new entry and a promise to finish the upload
      */
-    putMetadata(documentId: string, metadata: Metadata): Promise<FileEntry>;
+    putFile(id: string, bytes: Uint8Array): Promise<[RawFileEntry, Promise<void>]>;
+    /** the same as {@link putFile | `putFile`} but with caching for text */
+    putText(id: string, content: string): Promise<[RawFileEntry, Promise<void>]>;
+    /** the same as {@link putText | `putText`} but with extra validation for Content */
+    putContent(id: string, content: Content): Promise<[RawFileEntry, Promise<void>]>;
+    /** the same as {@link putText | `putText`} but with extra validation for Metadata */
+    putMetadata(id: string, metadata: Metadata): Promise<[RawFileEntry, Promise<void>]>;
     /**
-     * create a new collection (folder)
+     * put a set of entries to make an entry list file
+     *
+     * To fully upload an item:
+     * 1. upload all the constituent files and metadata
+     * 2. call this with all of the entries
+     * 3. append this entry to the root entry and call this again to update this root list
+     * 4. put the new root hash
+     *
+     * @param id - the id of the list to upload - this should be the item id if
+     *   uploading an item list, or "root" if uploading a new root list.
+     * @param entries - the entries to upload
+     * @returns the new list entry and a promise to finish the upload
+     */
+    putEntries(id: string, entries: RawEntry[]): Promise<[RawListEntry, Promise<void>]>;
+    /**
+     * dump the current cache to a string to preserve between session
      *
-     * @param visibleName - the name of the new folder
-     * @param parent - the documentId of the parent collection (folder)
+     * @returns a serialized version of the cache to pass to a new api instance
      */
-    putCollection(visibleName: string, parent?: string): Promise<CollectionEntry>;
+    dumpCache(): string;
+    /** completely clear the cache */
+    clearCache(): void;
+}
+/**
+ * the api for accessing remarkable functions
+ *
+ * There are roughly two types of functions.
+ * - high-level api functions that provide simple access with a single round
+ *   trip based on the web api
+ * - low-level wrapped functions that take more round trips, but provide more
+ *   control and may be faster since they can be cached.
+ *
+ * Most of these functions validate the return values so that typescript is
+ * accurate. However, sometimes those return values are more strict than the
+ * "true" underlying types. If this happens, please [submit a an
+ * issue](https://github.com/erikbrinkman/rmapi-js/issues). In the mean time,
+ * you should be able to use the low level api to work around any restrictive
+ * validation.
+ */
+export interface RemarkableApi {
+    /** scoped access to the raw low-level api */
+    raw: RawRemarkableApi;
     /**
-     * upload an epub
+     * list all items
      *
-     * @remarks this only uploads the raw data and returns an entry that could be
-     * uploaded as part of a larger collection. To make sure devices know about
-     * it, you'll still need to update the root hash, and potentially notify
-     * other devices.
+     * Items include both collections and documents. Documents that are in folders
+     * will have their parent set to something other than "" or "trash", but
+     * everything will be returned by this function.
      *
      * @example
-     * This example shows a full process upload. Note that it may fail if other
-     * devices are simultaneously syncing content. See {@link putRootHash} for
-     * more information.
-     *
      * ```ts
-     * const entry = await api.putEpub(...);
-     * await api.create(entry);
+     * await api.listItems();
      * ```
      *
-     * @param visibleName - the name to show for the uploaded epub
-     * @param buffer - the epub contents
-     * @param opts - extra options you can specify at upload
+     * @returns a list of all items with some metadata
      */
-    putEpub(visibleName: string, buffer: ArrayBuffer, opts?: PutEpubOptions): Promise<CollectionEntry>;
+    listItems(): Promise<Entry[]>;
     /**
-     * upload a pdf
+     * similar to {@link listItems | `listItems`} but backed by the low level api
      *
-     * @remarks this only uploads the raw data and returns an entry that could be
-     * uploaded as part of a larger collection. To make sure devices know about
-     * it, you'll still need to update the root hash, and potentially notify
-     * other devices.
+     * @param refresh - if true, refresh the root hash before listing
+     */
+    listIds(refresh?: boolean): Promise<SimpleEntry[]>;
+    /**
+     * get the content metadata from an item hash
      *
-     * @example
-     * This example shows a full process upload. Note that it may fail if other
-     * devices are simultaneously syncing content. See {@link putRootHash} for
-     * more information.
+     * This takes the high level item hash, e.g. the hashes you get from
+     * {@link listItems | `listItems`} or {@link listIds | `listIds`}.
      *
-     * ```ts
-     * const entry = await api.putPdf(...);
-     * await api.create(entry);
-     * ```
+     * @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.
      *
-     * @param visibleName - the name to show for the uploaded pdf
-     * @param buffer - the pdf contents
-     * @param opts - extra options you can specify at upload
+     * @param hash - the hash of the item to get content for
+     * @returns the content
      */
-    putPdf(visibleName: string, buffer: ArrayBuffer, opts?: PutPdfOptions): Promise<CollectionEntry>;
+    getContent(hash: string): Promise<Content>;
     /**
-     * indicate that a sync is complete and push updates to other devices
+     * get the metadata from an item hash
      *
-     * @remarks after successfully putting a new root hash, use this to indicate
-     * that other devices should pick up the change.
+     * This takes the high level item hash, e.g. the hashes you get from
+     * {@link listItems | `listItems`} or {@link listIds | `listIds`}.
+     *
+     * @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.
+     *
+     * @param hash - the hash of the item to get metadata for
+     * @returns the metadata
      */
-    syncComplete(generation: bigint): Promise<void>;
+    getMetadata(hash: string): Promise<Metadata>;
     /**
-     * high level api to create an entry
+     * get the pdf associated with a document hash
      *
-     * After creating a collection entry with
-     * {@link RemarkableApi.putCollection | `putCollection`},
-     * {@link RemarkableApi.putEpub | `putEpub`}, or
-     * {@link RemarkableApi.putPdf | `putPdf`}, this is a high level API to try
-     * syncing the change to the remarkable.
+     * This returns the raw input pdf, not the rendered pdf with any markup.
      *
-     * @remarks
-     * This API is provided to give a high level interface and to serve as an
-     * example of how to implement more advanced functionality, but it comes with
-     * a number of caveats:
-     * 1. For most use cases, it will repeat requests to remarkable's servers
-     *    (even with a cache) making it slower than implementing similar steps
-     *    manually.
-     * 2. It includes no handling of concurrent modification or other networking
-     *    errors, requiring repeat network requests if anything fails.
-     *
-     * However, with recent changes in the way this library caches results, it
-     * won't be terribly inefficient to just do multiple retries of create after
-     * uploading the file itself.
+     * @param hash - the hash of the document to get the pdf for (e.g. the hash
+     *     received from `listItems`)
+     * @returns the pdf bytes
+     */
+    getPdf(hash: string): Promise<Uint8Array>;
+    /**
+     * get the epub associated with a document hash
      *
-     * @example
-     * ```ts
-     * const entry = await api.putEpub(...);
-     * await api.create(entry);
-     * ```
+     * This returns the raw input epub if a document was created from an epub.
      *
-     * @param entry - and entry, usually created by a `put*` method
-     * @param options - any extra options for creation
-     * @returns synced - if sync was successful
-     * @throws error - if any error occurred, in this case, nothing will be
-     *   changed
+     * @param hash - the hash of the document to get the pdf for (e.g. the hash
+     *     received from `listItems`)
+     * @returns the epub bytes
      */
-    create(entry: CollectionEntry, options?: CreateMoveOptions): Promise<boolean>;
+    getEpub(hash: string): Promise<Uint8Array>;
     /**
-     * high level api to move a document / collection
+     * get the entire contents of a remarkable document
      *
-     * Use this as a high level api to move files in the document tree.
+     * This gets every file of associated with a document, and puts them into a
+     * zip archive.
      *
      * @remarks
-     * This API is provided to give a high level interface and to serve as an
-     * example of how to implement more advanced functionality, but it comes with
-     * a number of caveats:
-     * 1. For most use cases, it will repeat requests to remarkable's servers
-     *    (even with a cache) making it slower than implementing similar steps
-     *    manually.
-     * 2. It includes no handling of concurrent modification or other networking
-     *    errors, requiring repeat network requests if anything fails.
-     *
-     * However, with changes to the way this caches results, it won't be terribly
-     * inefficient to just retry calling `move` if there's a failure.
-     *
-     * @example
-     * ```ts
-     * const [root] = await api.getRootHash();
-     * const entries = await api.getEntries(root);
-     * const { documentId } = entries.find(...);
-     * await api.move(documentId, "trash");
-     * ```
+     * This is an experimental feature, that works for downloading the raw version
+     * of the document, but this format isn't understood enoguh to reput this on a
+     * different remarkable, so that functionality is currently disabled.
      *
-     * @param documentId - the document id of the document or collection to move
-     * @param dest - the new parent of this collection or document; this should
-     *   be the document id of an existing collection, an empty string for root,
-     *   or the string `"trash"` to move to the trash
-     * @param opts - any extra options for moving
-     * @returns synced - true if synced successfully
-     * @throws error - if any error occurred, in this case, nothing will be
-     *   changed
+     * @param hash - the hash of the document to get the contents for (e.g. the
+     *    hash received from `listItems`)
      */
-    move(documentId: string, dest: string, opts?: CreateMoveOptions): Promise<boolean>;
+    getDocument(hash: string): Promise<Uint8Array>;
     /**
-     * get metadata on all entries
-     *
-     * @remarks this uses a newer api, that returns metadata associated with all
-     * entries and their hash and documentId.
+     * use the low-level api to add a pdf document
+     *
+     * Since this uses the low-level api, it provides more options than
+     * {@link uploadPdf | `uploadPdf`}, but is a little more finicky. Notably, it
+     * may throw a {@link GenerationError | `GenerationError`} if the generation
+     * doesn't match the current server generation, requiring you to retry until
+     * it works.
+     *
+     * @param visibleName - the name to display on the reMarkable
+     * @param buffer - the raw pdf
+     * @param opts - put options
+     * @throws GenerationError if the generation doesn't match the current server generation
+     * @returns the entry for the newly inserted document
+     */
+    putPdf(visibleName: string, buffer: Uint8Array, opts?: PutOptions): Promise<SimpleEntry>;
+    /**
+     * use the low-level api to add an epub document
+     *
+     * Since this uses the low-level api, it provides more options than
+     * {@link uploadEpub | `uploadEpub`}, but is a little more finicky. Notably, it
+     * may throw a {@link GenerationError | `GenerationError`} if the generation
+     * doesn't match the current server generation, requiring you to retry until
+     * it works.
+     *
+     * @param visibleName - the name to display on the reMarkable
+     * @param buffer - the raw epub
+     * @param opts - put options
+     * @throws GenerationError if the generation doesn't match the current server generation
+     * @returns the entry for the newly inserted document
      */
-    getEntriesMetadata(opts?: GetOptions): Promise<MetadataEntry[]>;
+    putEpub(visibleName: string, buffer: Uint8Array, opts?: PutOptions): Promise<SimpleEntry>;
+    /** create a folder */
+    createFolder(visibleName: string, opts?: UploadOptions): Promise<SimpleEntry>;
     /**
      * upload an epub
      *
-     * @remarks this uses a newer api that performs a full upload and sync, but
-     * doesn't allow adding the same level of extra content data. Useful if you
-     * just want to upload a document with no fuss.
-     *
      * @example
      * ```ts
      * await api.uploadEpub("My EPub", ...);
@@ -595,17 +790,10 @@ export interface RemarkableApi {
      * @param visibleName - the name to show for the uploaded epub
      * @param buffer - the epub contents
      */
-    uploadEpub(visibleName: string, buffer: ArrayBuffer, opts?: GetOptions): Promise<UploadEntry>;
+    uploadEpub(visibleName: string, buffer: Uint8Array, opts?: UploadOptions): Promise<SimpleEntry>;
     /**
      * upload a pdf
      *
-     * this currently uploads invalid pdfs, but it's not clear why, which is why
-     * this is marked as experimental. Potentially some tweak in the formatting
-     * of buffer will fix it.
-     *
-     * @remarks this uses a newer api that performs a full upload and sync, but
-     * doesn't allow adding the same level of extra information.
-     *
      * @example
      * ```ts
      * await api.uploadPdf("My PDF", ...);
@@ -613,47 +801,97 @@ export interface RemarkableApi {
      *
      * @param visibleName - the name to show for the uploaded epub
      * @param buffer - the epub contents
-     * @experimental
      */
-    uploadPdf(visibleName: string, buffer: ArrayBuffer, opts?: GetOptions): Promise<UploadEntry>;
+    uploadPdf(visibleName: string, buffer: Uint8Array, opts?: UploadOptions): Promise<SimpleEntry>;
     /**
-     * get the current state of the cache for persisting
+     * move an entry
      *
-     * This won't include items that weren't cached because they were too big,
-     * meaning it won't prevent duplicate puts of large content across sessions.
+     * @example
+     * ```ts
+     * await api.move(doc.hash, dir.id);
+     * ```
+     *
+     * @param hash - the hash of the file to move
+     * @param parent - the id of the directory to move the entry to, "" (root) and "trash" are special parents
      */
-    getCache(): Promise<Map<string, ArrayBuffer>>;
-}
-/** format an entry */
-export declare function formatEntry({ hash, type, documentId, subfiles, size, }: Entry): string;
-/** parse an entry */
-export declare function parseEntry(line: string): Entry;
-/** options for a remarkable instance */
-export interface RemarkableOptions {
+    move(hash: string, parent: string): Promise<HashEntry>;
     /**
-     * the fetch method to use
+     * delete an entry
      *
-     * This should loosely conform to the WHATWG fetch, but is relaxed enough that
-     * node-fetch also works. This will default to the global definitions of
-     * fetch.
+     * @example
+     * ```ts
+     * await api.delete(file.hash);
+     * ```
+     * @param hash - the hash of the entry to delete
+     */
+    delete(hash: string): Promise<HashEntry>;
+    /**
+     * rename an entry
      *
-     * In node you can either use `"node-fetch"`, or `node --experimental-fetch`
-     * for node 17.5 or higher.
+     * @example
+     * ```ts
+     * await api.rename(file.hash, "new name");
+     * ```
+     * @param hash - the hash of the entry to rename
+     * @param visibleName - the new name to assign
+     */
+    rename(hash: string, visibleName: string): Promise<HashEntry>;
+    /**
+     * move many entries
+     *
+     * @example
+     * ```ts
+     * await api.bulkMove([file.hash], dir.id);
+     * ```
+     *
+     * @param hashes - an array of entry hashes to move
+     * @param parent - the directory id to move the entries to, "" (root) and "trash" are special ids
+     */
+    bulkMove(hashes: readonly string[], parent: string): Promise<HashesEntry>;
+    /**
+     * delete many entries
+     *
+     * @example
+     * ```ts
+     * await api.bulkDelete([file.hash]);
+     * ```
+     *
+     * @param hashes - the hashes of the entries to delete
+     */
+    bulkDelete(hashes: readonly string[]): Promise<HashesEntry>;
+    /**
+     * get the current cache value as a string
      *
-     * @defaultValue globalThis.fetch
+     * You can use this to warm start a new instance of
+     * {@link remarkable | `remarkable`} with any previously cached results.
      */
-    fetch?: FetchLike;
+    dumpCache(): string;
     /**
-     * a subtle-crypto-like object
+     * prune the cache so that it contains only reachable hashes
      *
-     * This should have a digest function like the api of `crypto.subtle`, it's
-     * default value.  In node try
-     * `import { webcrypto } from "crypto"; global.crypto = webcrypto` or pass in
-     * `webcrypto.subtle`.
+     * The cache is append only, so it can grow without bound, even as hashes
+     * become unreachable. In the future, this may have better cache management to
+     * track this in real time, but for now, you can call this method, to keep it
+     * from growing continuously.
+     *
+     * @remarks
+     * This won't necessarily reduce the cache size. In order to see if
+     * hashes are reachable we first have to search through all existing entry
+     * lists.
+     *
+     * @param refresh - whether to refresh the root hash before pruning
+     */
+    pruneCache(refresh?: boolean): Promise<void>;
+    /**
+     * completely delete the cache
      *
-     * @defaultValue globalThis.crypto.subtle
+     * If the cache is causing memory issues, you can clear it, but this will hurt
+     * performance.
      */
-    subtle?: SubtleCryptoLike;
+    clearCache(): void;
+}
+/** options for a remarkable instance */
+export interface RemarkableOptions {
     /**
      * the url for making authorization requests
      *
@@ -663,30 +901,32 @@ export interface RemarkableOptions {
     /**
      * the url for making synchronization requests
      *
-     * @defaultValue "https://internal.cloud.remarkable.com"
+     * @defaultValue "https://web.eu.tectonic.remarkable.com"
      */
     syncHost?: string;
     /**
-     * the maximum size in bytes to cache the value of a stored object
-     *
-     * Since the remarkableApi is based around hashes, the value of a hash should
-     * never change (barring collisions in ASH256). Any known hash value that's
-     * less than this amount will be cached locally to prevent future network
-     * requests. In addition, all successful puts and gets will be cached to
-     * prevent duplicate puts in the future.
+     * the url for making requests using the low-level api
      *
-     * To save memory and disable fetch caching, set to 0.
+     * @defaultValue "https://eu.tectonic.remarkable.com"
+     */
+    rawHost?: string;
+    /**
+     * an initial cache value
      *
-     * @defaultValue 1 MiB
+     * Generated from calling {@link RemarkableApi.dumpCache | `dumpCache`} on a previous
+     * instance.
      */
-    cacheLimitBytes?: number;
+    cache?: string;
     /**
-     * a set of values to use to initialize the cache
+     * the maximum size of the cache in terms of total string length
+     *
+     * By the JavaScript specification there are two bytes per character, but the
+     * total memory usage of the cache will also be larger than just the size of
+     * the data stored.
      *
-     * If this is inaccurate, then you could encounter errors with other methods.
-     * Often this will come from {@link RemarkableApi.getCache | `getCache`}.
+     * @defaultValue Infinity
      */
-    initCache?: Iterable<readonly [string, ArrayBuffer]>;
+    maxCacheSize?: number;
 }
 /**
  * create an instance of the api
@@ -698,4 +938,4 @@ export interface RemarkableOptions {
  *    registered. Create one with {@link register}.
  * @returns an api instance
  */
-export declare function remarkable(deviceToken: string, { fetch, subtle, authHost, syncHost, cacheLimitBytes, initCache, }?: RemarkableOptions): Promise<RemarkableApi>;
+export declare function remarkable(deviceToken: string, { authHost, syncHost, rawHost, cache, maxCacheSize, }?: RemarkableOptions): Promise<RemarkableApi>;