@filefreak.io/sdk 0.1.0 → 0.3.0

package/README.md

@@ -6,8 +6,10 @@ later and in browsers. No dependencies.
 Every endpoint is a function, typed from the same table the API is built
 from. Around them: uploads sent straight to storage in parts and carried on
 after an interruption, downloads fetched in ranges, listings and changes read
-to the end, and requests sent again only when that cannot make anything
-twice. The reference is at https://filefreak.io/developers/reference.
+to the end, files under Shard Protection sealed as they are sent and read
+through their maps, what a share link holds saved with no key, and requests sent again only when that
+cannot make anything twice. The reference is at
+https://filefreak.io/developers/reference.
 
 ## On a server
 
@@ -30,6 +32,12 @@ const bytes = await ff.bytes(file.id); // for a file small enough to hold in mem
 `fromPath` reads the file a part at a time as it is sent, so a file larger
 than memory is fine. `toPath` writes beside the file and gives it its name
 only once every byte is there: a download that fails leaves nothing behind.
+A file under Shard Protection has no address, and `download` and `bytes`
+read it through its map instead, each fragment checked as it arrives.
+Into a folder under Shard Protection, `upload` seals each part with the
+file's own key before it is sent, so none of the file is ever plain in
+storage. The key is asked of the API for the upload and kept nowhere, and
+an upload carried on asks which fragments storage has before it sends any.
 
 Keep keys on a server. A key sent from a web page is refused.
 
@@ -66,12 +74,44 @@ folder asked for, for a minute to an hour. It is checked against its key on
 every request, so revoking the key stops its tokens at once. A token cannot
 make another.
 
+## Saving from a link
+
+`get` saves what a share link or a public page holds. It needs no key, and
+sends nothing that says who is asking: no key, and from a browser no
+cookies. A file goes into one sink; a folder needs somewhere for each of its
+files, which `toFolder` makes on disk.
+
+```ts
+import { get } from "@filefreak.io/sdk";
+import { toFolder, toPath } from "@filefreak.io/sdk/node";
+
+await get("https://filefreak.link/share/...", await toPath("report.pdf"));
+
+const got = await get("https://filefreak.link/share/...", toFolder("downloads"), {
+  password: "open sesame", // for a link that has one
+  onProgress: (written, total) => console.log(`${written} of ${total} bytes`),
+});
+console.log(`${got.files.length} files, ${got.sizeBytes} bytes`);
+```
+
+It takes a share link, a public file's or folder's page, and a file's direct
+address. A folder comes whole: each file goes to the sink the function makes
+for it, given its name and the folders it is in. Each file saved is one of
+the link's downloads, as on its page, and a link with fewer left than there
+are files saves nothing (`not_enough_downloads`). A file under Shard
+Protection is read through the link's map, and counted once.
+
+Every name a link gives is its sharer's, and can be anything: `../../.bashrc`,
+or one that reads backwards. `toFolder` makes each one safe with `safeName`
+before writing, and never writes outside the folder it is given. A program
+that names files from a link itself should use `safeName` too.
+
 ## Every endpoint
 
 The functions are grouped as the reference groups the endpoints:
 `ff.files`, `ff.folders`, `ff.tree`, `ff.changes`, `ff.uploads`, `ff.usage`,
 `ff.me`, `ff.tokens` and `ff.shares` (share links, which only a device signed
-in with `ff login` may make). Ids in the address come first, then the body or
+in with `filefreak login` may make). Ids in the address come first, then the body or
 the query, then options:
 
 ```ts

package/dist/client.d.ts

@@ -66,7 +66,9 @@ export declare class FileFreak {
     /**
      * Fetch a file straight from storage into `sink`: as up to six ranges at
      * once for a large one. One download address is asked for, so the file is
-     * counted toward the month's downloads once. Resolves to the file.
+     * counted toward the month's downloads once. A file under Shard Protection
+     * has no address, and is read through its map instead (files.shards), each
+     * fragment checked as it arrives. Resolves to the file.
      */
     download(id: string, sink: Sink, options?: DownloadOptions): Promise<Item>;
     /** A file's bytes, in memory: for a file small enough to hold. */

package/dist/client.js

@@ -4,6 +4,7 @@
 // ranges, and reading a listing or the changes to the end.
 import { bind, OPERATIONS, } from "./generated.js";
 import { fetchRanges } from "./ranges.js";
+import { asItIsKept, readProtected } from "./reader.js";
 import { FileFreakError, sleep, Transport } from "./transport.js";
 import { upload } from "./uploads.js";
 /** How long a follow of the changes waits for one before asking again, unless told. */
@@ -90,7 +91,9 @@ export class FileFreak {
     /**
      * Fetch a file straight from storage into `sink`: as up to six ranges at
      * once for a large one. One download address is asked for, so the file is
-     * counted toward the month's downloads once. Resolves to the file.
+     * counted toward the month's downloads once. A file under Shard Protection
+     * has no address, and is read through its map instead (files.shards), each
+     * fragment checked as it arrives. Resolves to the file.
      */
     async download(id, sink, options = {}) {
         try {
@@ -117,18 +120,19 @@ export class FileFreak {
         // Nothing to fetch, and an address would count a download of nothing.
         if (item.sizeBytes === 0)
             return;
-        const { url } = await this.files.downloadUrl(item.id, {}, { signal: options.signal });
-        const progress = options.onProgress;
-        await fetchRanges({
-            url,
-            sizeBytes: item.sizeBytes,
+        const { signal, onProgress } = options;
+        const progress = onProgress && ((written) => onProgress(written, item.sizeBytes));
+        await asItIsKept(item.protected, async () => {
+            const { url } = await this.files.downloadUrl(item.id, {}, { signal });
+            await fetchRanges({ url, sizeBytes: item.sizeBytes, sink, signal, progress, ranges: options.ranges, fetch: this.transport.fetch, sleep: (ms) => sleep(ms, signal) });
+        }, () => readProtected({
+            pages: (from, pageSignal) => this.files.shards(item.id, { from }, { signal: pageSignal }),
             sink,
-            signal: options.signal,
-            progress: progress && ((written) => progress(written, item.sizeBytes)),
-            ranges: options.ranges,
+            sizeBytes: item.sizeBytes,
+            signal,
+            progress,
             fetch: this.transport.fetch,
-            sleep: (ms) => sleep(ms, options.signal),
-        });
+        }));
     }
 }
 /** Every item in a listing, a page at a time. */

package/dist/generated.d.ts

@@ -23,6 +23,10 @@ export interface Item {
     revision: number;
     /** The SHA-256 the uploader gave when it completed the upload of this content, in lower-case hex, or null. The uploader's word: this service never sees a file's bytes and does not check it. */
     clientSha256: string | null;
+    /** Whether the file is under Shard Protection: kept as sealed fragments, and read through its map (files.shards) rather than from an address. */
+    protected: boolean;
+    /** Its own Shard Protection setting. inherit follows the nearest folder above it that has one, and with none the drive's default: the app's, which its owner turns on from the app's page, or for a device the account's. The nearest setting wins. A file is converted within a few minutes of a change, and protected says when it has been. */
+    protection: "on" | "off" | "inherit";
     createdAt: string;
     updatedAt: string;
 }
@@ -122,7 +126,7 @@ export interface SiteDeploy {
     number: number;
     /** uploading: files are being declared and sent. ready: every file is stored, and it can be made live. cancelled or expired: given up on, and it holds nothing. */
     state: "uploading" | "ready" | "cancelled" | "expired";
-    /** upload: sent by ff. folder: copied from a folder in the drive, on the website. */
+    /** upload: sent from a computer, by the CLI or a program. folder: copied from a folder in the drive, on the website. */
     source: "upload" | "folder";
     fileCount: number;
     /** What its files add up to. */
@@ -147,6 +151,36 @@ export interface SendTo {
     /** When the address stops working. sites.sendAgain gives fresh ones. */
     expiresAt: string;
 }
+/** A page of a protected file's map: its key, and where each fragment is. */
+export interface ShardMap {
+    /** The content's own id, which each fragment's check is bound to with its place and the count. */
+    contentId: string;
+    /** The file's size. */
+    sizeBytes: number;
+    /** How many bytes of the file each fragment holds, except the last, which holds what remains. */
+    fragmentBytes: number;
+    /** How many fragments the file is. */
+    count: number;
+    /** The file's own key, in base64: 32 bytes, which open its fragments. In this answer and nowhere else. */
+    key: string;
+    name: string;
+    contentType: string | null;
+    /** The file's revision whose content this is. Its fragments never change, however late they are read. */
+    revision: number;
+    /** The first place on this page. */
+    from: number;
+    /** Up to 1000, in order of place. */
+    fragments: Array<{
+        /** Counted from zero. Its bytes of the file begin at place times fragmentBytes. */
+        place: number;
+        /** Where to fetch the stored fragment, with a plain GET and no key: the address is the permission. */
+        url: string;
+    }>;
+    /** The from of the next page, or null when this page reaches the last fragment. */
+    next: number | null;
+    /** When this page's addresses stop working. Ask for the page again before then, from the first fragment not yet fetched. */
+    expiresAt: string;
+}
 /** What GET /v1/files takes in its query. */
 export type FilesListQuery = {
     /** The folder to list. Left out, the top of the app (or of the folder the key is confined to). */
@@ -182,6 +216,8 @@ export type FilesUpdateBody = {
     parentId?: string | null;
     /** public, private, or inherit to follow the folder it is in. */
     visibility?: "private" | "public" | "inherit";
+    /** on, off, or inherit to follow the folder it is in. */
+    protection?: "on" | "off" | "inherit";
 };
 /** What PATCH /v1/files/:id answers with. */
 export type FilesUpdateAnswer = {
@@ -272,6 +308,8 @@ export type UploadsBeginBody = {
         /** The block's SHA-256 in hex. */
         sha256: string;
     }>;
+    /** true when this program can seal fragments as it sends them, as the SDK and the CLI do. Into a protected place the answer's shards is then set, and each part is a fragment. */
+    protectable?: boolean;
 };
 /** What POST /v1/uploads answers with. */
 export type UploadsBeginAnswer = {
@@ -280,6 +318,15 @@ export type UploadsBeginAnswer = {
     parts: Array<Part>;
     /** For an upload begun with blocks: the parts not to send, because storage has them already, from the file this replaces, or because they repeat a block an earlier part sends. Empty otherwise. Nothing is taken from the file this replaces when the key may not read it, when the file has not been opened or changed in 90 days, or when copying it would take the account past 1000 GB copied this way in an hour: every block is sent then. */
     reused: Array<number>;
+    /** Set when the upload is sealed as it is sent: how the file is cut into fragments. The key to seal them with is given by uploads.get. Null for an upload sent as it is. */
+    shards: {
+        /** The content's own id, which each fragment's seal is bound to with its place and the count. */
+        contentId: string;
+        /** How many bytes of the file each fragment holds, except the last, which holds what remains. */
+        fragmentBytes: number;
+        /** How many fragments, one to each part. */
+        count: number;
+    } | null;
 };
 /** What GET /v1/uploads/:id answers with. */
 export type UploadsGetAnswer = {
@@ -293,6 +340,17 @@ export type UploadsGetAnswer = {
     }> | null;
     /** As in the answer that began the upload: the parts not to send. */
     reused: Array<number>;
+    /** For an upload sealed as it is sent: how the file is cut, and the key to seal each fragment with. Null for an upload sent as it is, and for one that has ended. */
+    shards: {
+        /** The content's own id, which each fragment's seal is bound to with its place and the count. */
+        contentId: string;
+        /** The file's own key, in base64: 32 bytes, which open its fragments. In this answer and nowhere else. */
+        key: string;
+        /** How many bytes of the file each fragment holds, except the last, which holds what remains. */
+        fragmentBytes: number;
+        /** How many fragments, one to each part. */
+        count: number;
+    } | null;
 };
 /** What GET /v1/uploads/:id/parts takes in its query. */
 export type UploadsPartsQuery = {
@@ -304,6 +362,20 @@ export type UploadsPartsQuery = {
 export type UploadsPartsAnswer = {
     parts: Array<Part>;
 };
+/** What POST /v1/uploads/:id/fragments takes as its body. */
+export type UploadsFragmentsBody = {
+    /** The places of fragments that have been sent: up to 100 at a time. */
+    places: Array<number>;
+};
+/** What POST /v1/uploads/:id/fragments answers with. */
+export type UploadsFragmentsAnswer = {
+    /** At their own names, the size their places hold, and recorded. Never send them again. */
+    recorded: Array<number>;
+    /** Still being copied, or being confirmed by another request. Ask again shortly. */
+    pending: Array<number>;
+    /** Not in storage, or not their size and removed. Seal each again, under a new nonce, and send and confirm it. */
+    resend: Array<number>;
+};
 /** What POST /v1/uploads/:id/complete takes as its body. */
 export type UploadsCompleteBody = {
     /** The file's SHA-256 in hex, as you worked it out. Kept with the file as your word, since this service never sees the bytes, and given back as clientSha256, so a copy can be checked later without reading the file again. */
@@ -328,6 +400,13 @@ export type FilesDownloadUrlAnswer = {
     inline: boolean;
     contentType: string | null;
 };
+/** What GET /v1/files/:id/shards takes in its query. */
+export type FilesShardsQuery = {
+    /** The first fragment wanted, counted from zero: 0, or the `next` of the page before. */
+    from?: number;
+};
+/** What GET /v1/files/:id/shards answers with. */
+export type FilesShardsAnswer = ShardMap;
 /** What GET /v1/files/:id/image takes in its query. */
 export type FilesImageQuery = {
     /** One of 64, 128, 256, 512, 1024. */
@@ -367,7 +446,7 @@ export type UsageGetAnswer = {
 };
 /** What GET /v1/me answers with. */
 export type MeGetAnswer = {
-    /** key: an app's key, on a server. token: a token a key made for a web page. device: a person, signed in with ff login. */
+    /** key: an app's key, on a server. token: a token a key made for a web page. device: a person, signed in with filefreak login. */
     via: "key" | "token" | "device";
     account: {
         username: string;
@@ -603,6 +682,12 @@ export declare const OPERATIONS: {
         readonly idempotent: false;
         readonly repeatable: false;
     };
+    readonly "uploads.fragments": {
+        readonly method: "POST";
+        readonly path: "/v1/uploads/:id/fragments";
+        readonly idempotent: false;
+        readonly repeatable: true;
+    };
     readonly "uploads.complete": {
         readonly method: "POST";
         readonly path: "/v1/uploads/:id/complete";
@@ -621,6 +706,12 @@ export declare const OPERATIONS: {
         readonly idempotent: false;
         readonly repeatable: false;
     };
+    readonly "files.shards": {
+        readonly method: "GET";
+        readonly path: "/v1/files/:id/shards";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
     readonly "files.image": {
         readonly method: "GET";
         readonly path: "/v1/files/:id/image";
@@ -758,6 +849,8 @@ export declare function bind(call: Call): {
          *
          * Any of the three, in one request. They are applied in that order, each as its own change: if the second is refused the first has still happened, and the answer says which was refused. Moving a folder moves everything in it and is one change however much that is. Making a folder public makes everything in it public, except what has a setting of its own.
          *
+         * protection is a fourth, applied last: on puts the file or folder under Shard Protection, off takes it out, and inherit has it follow the folder it is in. A folder's setting reaches everything in it that has none of its own. Turning it on is refused while the account's plan does not include it (402 shard_protection_needs_pro); turning it off never is. Nothing is converted in this request: the service converts each file within a few minutes, and its protected says when. A key confined to a folder decides about what is in it, and not about the folder.
+         *
          * PATCH /v1/files/:id. Needs the scope files:write.
          */
         update: (id: string, body: FilesUpdateBody, options?: CallOptions) => Promise<FilesUpdateAnswer>;
@@ -780,11 +873,19 @@ export declare function bind(call: Call): {
         /**
          * An address to download a file from.
          *
-         * A short-lived address on storage itself. Anybody holding it can fetch the file until it expires, with no key, so it can be handed to a browser. Each one issued counts the file's size toward the month's downloads. For an address that does not expire, make the file public and use its publicUrl. A file under Shard Protection is answered with 409 shard_protected: the developer API cannot read protected files yet.
+         * A short-lived address on storage itself. Anybody holding it can fetch the file until it expires, with no key, so it can be handed to a browser. Each one issued counts the file's size toward the month's downloads. For an address that does not expire, make the file public and use its publicUrl. A file under Shard Protection has no address: it is answered with 409 shard_protected, and read through its map with files.shards.
          *
          * GET /v1/files/:id/download. Needs the scope files:read.
          */
         downloadUrl: (id: string, query?: FilesDownloadUrlQuery, options?: CallOptions) => Promise<FilesDownloadUrlAnswer>;
+        /**
+         * A protected file's map.
+         *
+         * A file under Shard Protection is kept as fragments, each sealed with the file's own key and stored across several storage accounts. Its map says where each fragment is, up to 1,000 at a time, with the key. Fetch each fragment from its address (no key: the address is the permission), check and open it as the SDK's openFragment does, and write it at its place. The first page counts the file's size toward the month's downloads; later pages count nothing. Addresses work for four hours: before then, ask for the page again from the first fragment not yet fetched. The key is in this answer and nowhere else. This API never keeps it, and neither should a program, beyond the read.
+         *
+         * GET /v1/files/:id/shards. Needs the scope files:read.
+         */
+        shards: (id: string, query?: FilesShardsQuery, options?: CallOptions) => Promise<FilesShardsAnswer>;
         /**
          * An image at a smaller size.
          *
@@ -836,13 +937,15 @@ export declare function bind(call: Call): {
          *
          * The room is set aside now, so an upload that would not fit is refused before a byte is sent. The parts can be sent by anything that can make a PUT request, including a browser that has never seen the API key: hand it the addresses.
          *
+         * Into a place under Shard Protection, an upload begun with protectable true is sealed as it is sent. A place is protected by the setting nearest it (files.update's protection), or with none by the drive's default: an app's, which its owner turns on from the app's page, or for a device the account's. The answer's shards then says how the file is cut, and uploads.get gives its key. Each part is a fragment: the file's bytes from its number times fragmentBytes, sealed with that key as the SDK's sealFragment does, under a nonce of its own, and sent to the part's address. uploads.fragments confirms them, and completing makes the file, protected from its first byte, with a null clientSha256. A sealed upload sets blocks aside: none is kept, and none reused. Begun without protectable, a file lands as an ordinary file and the service protects it within a few minutes; from then on it is read through its map (files.shards).
+         *
          * POST /v1/uploads. Needs the scope files:write. Honours an Idempotency-Key.
          */
         begin: (body: UploadsBeginBody, options?: CallOptions) => Promise<UploadsBeginAnswer>;
         /**
          * An upload, and which parts have arrived.
          *
-         * For carrying on after an interruption: storage itself says which parts it has, so nothing the client remembered is needed.
+         * For carrying on after an interruption: storage itself says which parts it has, so nothing the client remembered is needed. For an upload sealed as it is sent, uploadedParts are the fragments confirmed and recorded, and shards gives the key, which this API keeps nowhere else. Confirm any fragment that may have been sent before sending it again. This answer is never kept, by this API or anything between it and the caller.
          *
          * GET /v1/uploads/:id. Needs the scope files:write.
          */
@@ -850,11 +953,19 @@ export declare function bind(call: Call): {
         /**
          * Addresses for more parts.
          *
-         * Addresses are given out a window at a time and each lasts half an hour. Ask again for any that have run out.
+         * Addresses are given out a window at a time and each lasts half an hour. Ask again for any that have run out. For an upload sealed as it is sent, each number is a fragment's place, and its address takes the sealed fragment, with its Content-MD5. Confirm fragments with uploads.fragments once they are sent.
          *
          * GET /v1/uploads/:id/parts. Needs the scope files:write.
          */
         parts: (id: string, query?: UploadsPartsQuery, options?: CallOptions) => Promise<UploadsPartsAnswer>;
+        /**
+         * Confirm sealed fragments.
+         *
+         * Confirms fragments of a sealed upload that have been sent. Each is copied inside storage to its own name, measured, and recorded once it is the size its place holds. recorded: done, never send it again. pending: storage is still copying it, or another confirmation of it is under way, so ask again shortly. resend: not there, or not its size and removed, so seal it again, under a new nonce, send it and confirm it. Safe to send again.
+         *
+         * POST /v1/uploads/:id/fragments. Needs the scope files:write. Safe to send again.
+         */
+        fragments: (id: string, body: UploadsFragmentsBody, options?: CallOptions) => Promise<UploadsFragmentsAnswer>;
         /**
          * Finish an upload.
          *
@@ -876,7 +987,7 @@ export declare function bind(call: Call): {
         /**
          * What the app is using.
          *
-         * What this app holds, against the ceiling set for it if there is one; and what the account it belongs to has used this calendar month, across its personal files and all its apps, against what its plan includes. An app's files count toward the account's one storage allowance. For a device signed in with ff login, which uses the personal drive, app is null.
+         * What this app holds, against the ceiling set for it if there is one; and what the account it belongs to has used this calendar month, across its personal files and all its apps, against what its plan includes. An app's files count toward the account's one storage allowance. For a device signed in with filefreak login, which uses the personal drive, app is null.
          *
          * GET /v1/usage. Needs the scope usage:read.
          */
@@ -886,7 +997,7 @@ export declare function bind(call: Call): {
         /**
          * Who this is.
          *
-         * The account a key, a token or a device acts for, and what it may do there. A key's program and a page's token are told the account's username and plan, never its email address: only a device signed in with ff login, which is the person, is told that.
+         * The account a key, a token or a device acts for, and what it may do there. A key's program and a page's token are told the account's username and plan, never its email address: only a device signed in with filefreak login, which is the person, is told that.
          *
          * GET /v1/me. Any key may call it.
          */
@@ -896,25 +1007,25 @@ export declare function bind(call: Call): {
         /**
          * Make a share link.
          *
-         * A link that opens one file or folder for whoever holds it, separate from making it public: a private file can have one. It can have a password, an end date and a number of downloads after which it stops. Share links are a person's, so only a device signed in with ff login can make them here, as on the website; an app's key cannot.
+         * A link that opens one file or folder for whoever holds it, separate from making it public: a private file can have one. It can have a password, an end date and a number of downloads after which it stops. Share links are a person's, so only a device signed in with filefreak login can make them here, as on the website; an app's key cannot. A link to a file under Shard Protection is a shard link: whoever opens it is given the file's key with its map, so their browser can put the file back together, show it and save it. The storage it is kept in still gives nobody anything on its own.
          *
-         * POST /v1/shares. Only a device signed in with ff login may call it. Honours an Idempotency-Key.
+         * POST /v1/shares. Only a device signed in with filefreak login may call it. Honours an Idempotency-Key.
          */
         create: (body: SharesCreateBody, options?: CallOptions) => Promise<SharesCreateAnswer>;
         /**
          * List share links.
          *
-         * The links on one file or folder, or every link the account has, newest first. Removed links are not listed. Only a device signed in with ff login.
+         * The links on one file or folder, or every link the account has, newest first. Removed links are not listed. Only a device signed in with filefreak login.
          *
-         * GET /v1/shares. Only a device signed in with ff login may call it.
+         * GET /v1/shares. Only a device signed in with filefreak login may call it.
          */
         list: (query?: SharesListQuery, options?: CallOptions) => Promise<SharesListAnswer>;
         /**
          * Remove a share link.
          *
-         * It stops working with the next request, and cannot be brought back. Only a device signed in with ff login.
+         * It stops working with the next request, and cannot be brought back. Only a device signed in with filefreak login.
          *
-         * DELETE /v1/shares/:id. Only a device signed in with ff login may call it.
+         * DELETE /v1/shares/:id. Only a device signed in with filefreak login may call it.
          */
         revoke: (id: string, options?: CallOptions) => Promise<SharesRevokeAnswer>;
     };
@@ -922,9 +1033,9 @@ export declare function bind(call: Call): {
         /**
          * List sites.
          *
-         * The account's static sites, by name, with the deploy each serves. A site is a person's, so only a device signed in with ff login reaches sites, as on the website; an app's key cannot. Sites are part of Pro.
+         * The account's static sites, by name, with the deploy each serves. A site is a person's, so only a device signed in with filefreak login reaches sites, as on the website; an app's key cannot. Sites are part of Pro.
          *
-         * GET /v1/sites. Only a device signed in with ff login may call it.
+         * GET /v1/sites. Only a device signed in with filefreak login may call it.
          */
         list: (options?: CallOptions) => Promise<SitesListAnswer>;
         /**
@@ -932,7 +1043,7 @@ export declare function bind(call: Call): {
          *
          * A site with no deploy yet. Its name is its address: 3 to 40 lower-case letters, digits and single hyphens, and not a name FileFreak keeps, another account's username, or one that looks like another company's (invalid_site_name, site_name_taken). Refused with sites_need_pro on a plan without sites.
          *
-         * POST /v1/sites. Only a device signed in with ff login may call it. Honours an Idempotency-Key.
+         * POST /v1/sites. Only a device signed in with filefreak login may call it. Honours an Idempotency-Key.
          */
         create: (body: SitesCreateBody, options?: CallOptions) => Promise<SitesCreateAnswer>;
         /**
@@ -940,7 +1051,7 @@ export declare function bind(call: Call): {
          *
          * A site, and its deploys newest first. A site keeps its 10 newest deploys that have ended besides the live one.
          *
-         * GET /v1/sites/:id. Only a device signed in with ff login may call it.
+         * GET /v1/sites/:id. Only a device signed in with filefreak login may call it.
          */
         get: (id: string, options?: CallOptions) => Promise<SitesGetAnswer>;
         /**
@@ -948,7 +1059,7 @@ export declare function bind(call: Call): {
          *
          * Begins a deploy with up to 1000 of its files: each one's path, size and SHA-256. Declare the rest with sites.declareFiles, more set to false on the last list. The answer says which files to send: PUT each one's bytes to its address, then call sites.finishDeploy. Bytes the site has stored already are not asked for. A deploy may have 20000 files, 100 MB each and 1 GB together, and what it adds counts as storage from the moment it is declared (quota_exceeded). An unfinished deploy nothing has asked about for an hour is given up on.
          *
-         * POST /v1/sites/:id/deploys. Only a device signed in with ff login may call it. Honours an Idempotency-Key.
+         * POST /v1/sites/:id/deploys. Only a device signed in with filefreak login may call it. Honours an Idempotency-Key.
          */
         startDeploy: (id: string, body: SitesStartDeployBody, options?: CallOptions) => Promise<SitesStartDeployAnswer>;
         /**
@@ -956,7 +1067,7 @@ export declare function bind(call: Call): {
          *
          * The next 1000 files of a deploy at most, as sites.startDeploy takes them. A path declared twice is refused (path_declared_twice).
          *
-         * POST /v1/sites/deploys/:id/files. Only a device signed in with ff login may call it. Honours an Idempotency-Key.
+         * POST /v1/sites/deploys/:id/files. Only a device signed in with filefreak login may call it. Honours an Idempotency-Key.
          */
         declareFiles: (id: string, body: SitesDeclareFilesBody, options?: CallOptions) => Promise<SitesDeclareFilesAnswer>;
         /**
@@ -964,7 +1075,7 @@ export declare function bind(call: Call): {
          *
          * New addresses for files of an unfinished deploy whose bytes have not arrived, when the first ones ran out or a finish answered deploy_incomplete. Files whose bytes have arrived are left out.
          *
-         * POST /v1/sites/deploys/:id/send. Only a device signed in with ff login may call it. Safe to send again.
+         * POST /v1/sites/deploys/:id/send. Only a device signed in with filefreak login may call it. Safe to send again.
          */
         sendAgain: (id: string, body: SitesSendAgainBody, options?: CallOptions) => Promise<SitesSendAgainAnswer>;
         /**
@@ -972,7 +1083,7 @@ export declare function bind(call: Call): {
          *
          * Storage puts each file in place and is asked its size, and the deploy is ready, and live if live is true. Safe to call again: storage may take longer than one request waits, and the answer is then 202 with how long to wait before asking again. A file whose bytes have not arrived, or arrived at another size, is answered with deploy_incomplete and the SHA-256s to send again.
          *
-         * POST /v1/sites/deploys/:id/finish. Only a device signed in with ff login may call it. Safe to send again.
+         * POST /v1/sites/deploys/:id/finish. Only a device signed in with filefreak login may call it. Safe to send again.
          */
         finishDeploy: (id: string, body?: SitesFinishDeployBody, options?: CallOptions) => Promise<SitesFinishDeployAnswer>;
         /**
@@ -980,7 +1091,7 @@ export declare function bind(call: Call): {
          *
          * Cancels a deploy that is uploading, and what it set aside is given back at once. Deletes one that has ended, with whatever bytes no other deploy of the site uses. Never the live one (deploy_live).
          *
-         * DELETE /v1/sites/deploys/:id. Only a device signed in with ff login may call it.
+         * DELETE /v1/sites/deploys/:id. Only a device signed in with filefreak login may call it.
          */
         removeDeploy: (id: string, options?: CallOptions) => Promise<SitesRemoveDeployAnswer>;
         /**
@@ -988,7 +1099,7 @@ export declare function bind(call: Call): {
          *
          * Makes a ready deploy the one visitors are served, which is also how a site is rolled back; null takes the site offline. Visitors see the change within a minute.
          *
-         * POST /v1/sites/:id/live. Only a device signed in with ff login may call it. Safe to send again.
+         * POST /v1/sites/:id/live. Only a device signed in with filefreak login may call it. Safe to send again.
          */
         setLive: (id: string, body: SitesSetLiveBody, options?: CallOptions) => Promise<SitesSetLiveAnswer>;
     };