rmapi-js 5.0.0 → 6.0.0

package/dist/index.d.ts

@@ -1,76 +1,50 @@
 /** request types */
-export type RequestMethod = "POST" | "GET" | "PUT" | "DELETE";
-/** text alignment types */
-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";
-    /** the hash of the collection this points to */
-    hash: string;
-    /** the unique id of the collection */
-    documentId: string;
-    /** the number of subfiles */
-    subfiles: number;
-    /** collections don't have sizes */
-    size: bigint;
+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 remarkable entry for cloud data */
-export interface FileEntry {
-    /** file type */
-    type: "0";
-    /** the hash of the file this points to */
+/** 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;
-    /** the unique id of the file */
-    documentId: string;
-    /** files don't have subfiles */
-    subfiles: 0;
-    /** size of the file */
-    size: bigint;
+    /** the visible display name of this entry */
+    visibleName: string;
+    /** 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;
+    /** any tags the entry might have */
+    tags?: Tag[];
+}
+/** a folder, referred to in the api as a collection */
+export interface CollectionEntry extends EntryCommon {
+    /** the key for this as a collection */
+    type: "CollectionType";
+}
+/** 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";
+    /** the type of the file */
+    fileType: "epub" | "pdf" | "notebook";
+    /** the timestamp of the last time this entry was opened */
+    lastOpened: string;
 }
 /** a remarkable entry for cloud items */
-export type Entry = CollectionEntry | FileEntry;
+export type Entry = CollectionEntry | DocumentType;
 /** an simple entry produced by the upload api */
 export interface UploadEntry {
     /** the document id */
@@ -78,117 +52,15 @@ export interface UploadEntry {
     /** the document hash */
     hash: string;
 }
-/** common metadata for documents and collections */
-export interface CommonMetadata {
-    /** name of content */
-    visibleName: string;
-    /** parent uuid (documentId) or "" for root or "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;
-}
-/** metadata for collection types */
-export interface CollectionTypeMetadata extends CommonMetadata {
-    /** the key for collection types */
-    type: "CollectionType";
-}
-/** metadata for document types */
-export interface DocumentTypeMetadata extends CommonMetadata {
-    /** the key for document types */
-    type: "DocumentType";
-    /** last opened time for documents */
-    lastOpened?: string;
-    /** last opened page for documents */
-    lastOpenedPage?: number;
-    /** created time */
-    createdTime?: 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 */
-    id: string;
-    /** the hash of the entry */
+/** the new hash of a modified entry */
+export interface HashEntry {
+    /** the actual hash */
     hash: string;
 }
-/** the metadata entry for a collection */
-export interface CollectionMetadataEntry extends BaseMetadataEntry, CollectionTypeMetadata {
-}
-/** the metadata entry for a document */
-export interface DocumentMetadataEntry extends BaseMetadataEntry, DocumentTypeMetadata {
-    /** the type of the document */
-    fileType: FileType;
-}
-/** 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
- *
- * This is found in the `.content` file.
- */
-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;
+/** 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>;
 }
 /** stripped down version of RequestInit */
 export interface RequestInitLike {
@@ -212,29 +84,13 @@ export interface ResponseLike {
     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>;
+    (url: string, options?: RequestInitLike): Promise<ResponseLike>;
 }
 /** an error that results from a failed request */
 export declare class ResponseError extends Error {
@@ -244,14 +100,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 {
@@ -282,67 +137,6 @@ export interface RegisterOptions {
  * @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;
-}
-/**
- * options for {@link RemarkableApi.getRootHash | `getRootHash`}
- */
-export interface GetRootHashOptions {
-    /**
-     * whether to use the last known valid root hash
-     *
-     * @defaultValue true
-     */
-    cache?: boolean;
-}
-/**
- * options for {@link RemarkableApi.create | `create`} and
- * {@link RemarkableApi.move | `move`}
- */
-export interface CreateMoveOptions {
-    /**
-     * whether to use the last known valid root hash
-     *
-     * @defaultValue true
-     */
-    cache?: boolean;
-    /**
-     * whether broadcast syncing complete to other devices
-     *
-     * @defaultValue true
-     */
-    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;
-}
 /** options for getting responses */
 export interface GetOptions {
     /**
@@ -353,281 +147,106 @@ export interface GetOptions {
      */
     verify?: boolean | undefined;
 }
+export interface UploadOptions extends GetOptions {
+    /** an optional parent id to set when uploading */
+    parent?: string;
+}
 /**
  * the api for accessing remarkable functions
  */
 export interface RemarkableApi {
     /**
-     * get the root hash and the current generation
+     * list all files
      *
-     * If this hasn't changed, then neither have any of the files.
-     */
-    getRootHash(options?: GetRootHashOptions): Promise<[string, bigint]>;
-    /**
-     * write the root hash, incrimenting from the current generation
-     *
-     * 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.
-     *
-     * @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);
+     * @example
+     * ```ts
+     * await api.listFiles();
      * ```
-     *
-     * @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.
-     */
-    putRootHash(hash: string, generation: bigint): Promise<bigint>;
-    /**
-     * get array buffer associated with a hash
-     *
-     * @param hash - the hash to get text data from
      */
-    getBuffer(hash: string): Promise<ArrayBuffer>;
-    /**
-     * get text content associated with hash
-     *
-     * @param hash - the hash to get text data from
-     */
-    getText(hash: string): Promise<string>;
-    /**
-     * get a json object associated with a hash
-     *
-     * This is identical to `getText(hash).then(JSON.parse)` and is only provided
-     * for consistency with {@link RemarkableApi.putJson | `putJson`}.
-     */
-    getJson(hash: string): Promise<unknown>;
-    /** get metadata from hash */
-    getMetadata(hash: string, opts?: GetOptions): Promise<Metadata>;
-    /**
-     * get entries from a collection hash
-     *
-     * If omitted, this will use `getRootHash()`.
-     */
-    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>;
-    /**
-     * put a raw text in the cloud encoded as utf-8
-     *
-     * this is no different than using `putBuffer(..., new TextEncoder().encode(contents))`
-     */
-    putText(documentId: string, contents: string): Promise<FileEntry>;
-    /**
-     * put json into the cloud
-     *
-     * This uses a stable (sorted keys) json serilization to preserve consistent
-     * hashes.
-     */
-    putJson(documentId: string, contents: object): Promise<FileEntry>;
-    /**
-     * put metadata into the cloud
-     *
-     * This is a small wrapper around {@link RemarkableApi.putText | `putText`}.
-     *
-     * @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
-     */
-    putMetadata(documentId: string, metadata: Metadata): Promise<FileEntry>;
-    /**
-     * create a new collection (folder)
-     *
-     * @param visibleName - the name of the new folder
-     * @param parent - the documentId of the parent collection (folder)
-     */
-    putCollection(visibleName: string, parent?: string): Promise<CollectionEntry>;
+    listFiles(ops?: GetOptions): Promise<Entry[]>;
+    /** create a folder */
+    createFolder(visibleName: string, opts?: UploadOptions): Promise<UploadEntry>;
     /**
      * upload an epub
      *
-     * @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.
-     *
      * @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.uploadEpub("My EPub", ...);
      * ```
      *
      * @param visibleName - the name to show for the uploaded epub
      * @param buffer - the epub contents
-     * @param opts - extra options you can specify at upload
      */
-    putEpub(visibleName: string, buffer: ArrayBuffer, opts?: PutEpubOptions): Promise<CollectionEntry>;
+    uploadEpub(visibleName: string, buffer: ArrayBuffer, opts?: UploadOptions): Promise<UploadEntry>;
     /**
      * upload a pdf
      *
-     * @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.
-     *
      * @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.putPdf(...);
-     * await api.create(entry);
+     * await api.uploadPdf("My PDF", ...);
      * ```
      *
-     * @param visibleName - the name to show for the uploaded pdf
-     * @param buffer - the pdf contents
-     * @param opts - extra options you can specify at upload
-     */
-    putPdf(visibleName: string, buffer: ArrayBuffer, opts?: PutPdfOptions): Promise<CollectionEntry>;
-    /**
-     * indicate that a sync is complete and push updates to other devices
-     *
-     * @remarks after successfully putting a new root hash, use this to indicate
-     * that other devices should pick up the change.
+     * @param visibleName - the name to show for the uploaded epub
+     * @param buffer - the epub contents
      */
-    syncComplete(generation: bigint): Promise<void>;
+    uploadPdf(visibleName: string, buffer: ArrayBuffer, opts?: UploadOptions): Promise<UploadEntry>;
     /**
-     * high level api to create an entry
-     *
-     * 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.
-     *
-     * @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.
+     * move an entry
      *
      * @example
      * ```ts
-     * const entry = await api.putEpub(...);
-     * await api.create(entry);
+     * await api.move(doc.hash, dir.id);
      * ```
      *
-     * @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 file to move
+     * @param parent - the id of the directory to move the entry to, "" (root) and "trash" are special parents
      */
-    create(entry: CollectionEntry, options?: CreateMoveOptions): Promise<boolean>;
+    move(hash: string, parent: string, opts?: GetOptions): Promise<HashEntry>;
     /**
-     * high level api to move a document / collection
-     *
-     * Use this as a high level api to move files in the document tree.
-     *
-     * @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.
+     * delete an entry
      *
      * @example
      * ```ts
-     * const [root] = await api.getRootHash();
-     * const entries = await api.getEntries(root);
-     * const { documentId } = entries.find(...);
-     * await api.move(documentId, "trash");
+     * await api.delete(file.hash);
      * ```
-     *
-     * @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 entry to delete
      */
-    move(documentId: string, dest: string, opts?: CreateMoveOptions): Promise<boolean>;
+    delete(hash: string, opts?: GetOptions): Promise<HashEntry>;
     /**
-     * get metadata on all entries
+     * rename an entry
      *
-     * @remarks this uses a newer api, that returns metadata associated with all
-     * entries and their hash and documentId.
+     * @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
      */
-    getEntriesMetadata(opts?: GetOptions): Promise<MetadataEntry[]>;
+    rename(hash: string, visibleName: string, opts?: GetOptions): Promise<HashEntry>;
     /**
-     * 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.
+     * move many entries
      *
      * @example
      * ```ts
-     * await api.uploadEpub("My EPub", ...);
+     * await api.bulkMove([file.hash], dir.id);
      * ```
      *
-     * @param visibleName - the name to show for the uploaded epub
-     * @param buffer - the epub contents
+     * @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
      */
-    uploadEpub(visibleName: string, buffer: ArrayBuffer, opts?: GetOptions): Promise<UploadEntry>;
+    bulkMove(hashes: readonly string[], parent: string, opts?: GetOptions): Promise<HashesEntry>;
     /**
-     * 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.
+     * delete many entries
      *
      * @example
      * ```ts
-     * await api.uploadPdf("My PDF", ...);
+     * await api.bulkDelete([file.hash]);
      * ```
      *
-     * @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>;
-    /**
-     * get the current state of the cache for persisting
-     *
-     * 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.
+     * @param hashes - the hashes of the entries to delete
      */
-    getCache(): Promise<Map<string, ArrayBuffer>>;
+    bulkDelete(hashes: readonly string[], opts?: GetOptions): Promise<HashesEntry>;
 }
-/** 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 {
     /**
@@ -643,17 +262,6 @@ export interface RemarkableOptions {
      * @defaultValue globalThis.fetch
      */
     fetch?: FetchLike;
-    /**
-     * a subtle-crypto-like object
-     *
-     * 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`.
-     *
-     * @defaultValue globalThis.crypto.subtle
-     */
-    subtle?: SubtleCryptoLike;
     /**
      * the url for making authorization requests
      *
@@ -666,27 +274,6 @@ export interface RemarkableOptions {
      * @defaultValue "https://internal.cloud.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.
-     *
-     * To save memory and disable fetch caching, set to 0.
-     *
-     * @defaultValue 1 MiB
-     */
-    cacheLimitBytes?: number;
-    /**
-     * a set of values to use to initialize the cache
-     *
-     * If this is inaccurate, then you could encounter errors with other methods.
-     * Often this will come from {@link RemarkableApi.getCache | `getCache`}.
-     */
-    initCache?: Iterable<readonly [string, ArrayBuffer]>;
 }
 /**
  * create an instance of the api
@@ -698,4 +285,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, { fetch, authHost, syncHost, }?: RemarkableOptions): Promise<RemarkableApi>;