@filefreak.io/sdk 0.0.0-stage → 0.2.0

package/dist/generated.d.ts

@@ -0,0 +1,1060 @@
+import type { CallOptions } from "./transport.js";
+/** A file or folder. */
+export interface Item {
+    /** Never changes, whatever is renamed or moved. */
+    id: string;
+    kind: "file" | "folder";
+    name: string;
+    /** The folder it is in. Null at the top of the app. */
+    parentId: string | null;
+    /** Zero for a folder. */
+    sizeBytes: number;
+    /** Null for a folder. */
+    contentType: string | null;
+    /** Its own setting. inherit follows the nearest folder above it that has one, and with none it is private. The nearest setting wins: a private file inside a public folder is private, and a public file inside a private folder is public. */
+    visibility: "private" | "public" | "inherit";
+    /** Whether anybody can see it now: by the nearest setting, with nothing above it in the trash, and the account's public page switched on. */
+    public: boolean;
+    /** An address anybody can fetch, that does not expire, while the file is public. Null for a folder and for anything that is not public. */
+    publicUrl: string | null;
+    /** When it was put in the trash, if it is there. */
+    trashedAt: string | null;
+    /** One more each time an upload replaces the file's content. Renaming or moving leaves it as it is. Always 1 for a folder. */
+    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;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One change to a file or folder, saying what it is now. */
+export interface Change {
+    /** The file or folder's id. */
+    id: string;
+    kind: "file" | "folder";
+    /** What it is now. live: in the folder parentId names, called name. trashed: in the trash, with everything inside it. deleted: gone for good, with everything that was inside it. */
+    state: "live" | "trashed" | "deleted";
+    /** The folder it is in, or was in when it went. Null at the top of the app. */
+    parentId: string | null;
+    name: string;
+    /** Zero for a folder. */
+    sizeBytes: number;
+    revision: number;
+    clientSha256: string | null;
+    changedAt: string;
+}
+/** A file on its way to storage. */
+export interface Upload {
+    id: string;
+    name: string;
+    parentId: string | null;
+    sizeBytes: number;
+    contentType: string | null;
+    status: "pending" | "completed" | "aborted" | "expired";
+    onConflict: "rename" | "replace" | "fail";
+    /** Every part is this many bytes, except the last, which is whatever remains. For an upload begun with blocks, each part is its block, and this is the largest of them. */
+    partBytes: number;
+    partCount: number;
+    /** The file this became, once it has. */
+    fileId: string | null;
+    /** The upload has to be completed by then. */
+    expiresAt: string;
+    createdAt: string;
+}
+/** Where to send one part of an upload. */
+export interface Part {
+    /** Counted from zero. */
+    number: number;
+    method: "PUT";
+    /** Send this part's bytes here, as the body. No API key: the address is the permission. Add a Content-MD5 header, the part's MD5 in base64, and storage checks it and refuses a part that changed on the way. */
+    url: string;
+    /** Headers the request must carry. */
+    headers: Record<string, string>;
+    /** When this address stops working. Ask for the parts again to get fresh ones. */
+    expiresAt: string;
+}
+/** Not ready yet: ask again after retryAfterSeconds. */
+export interface Pending {
+    pending: true;
+    retryAfterSeconds: number;
+}
+/** Done. */
+export interface Ok {
+    ok: true;
+}
+/** A link that opens one file or folder for whoever holds it. */
+export interface Share {
+    id: string;
+    /** The file or folder it opens. */
+    itemId: string;
+    /** The link to give. Whoever has it can open what it is for, with the password if it has one. */
+    url: string;
+    hasPassword: boolean;
+    /** When it stops working, or null for never. */
+    expiresAt: string | null;
+    /** How many downloads it allows, or null for any number. */
+    maxDownloads: number | null;
+    downloadCount: number;
+    lastUsedAt: string | null;
+    createdAt: string;
+    /** Whether it works now, and if not, why. */
+    state: "active" | "expired" | "used_up";
+}
+/** A static site: a name under the sites domain, and its deploys. */
+export interface Site {
+    id: string;
+    /** Lower-case letters, digits and hyphens. The site's address is this name under the sites domain. */
+    name: string;
+    /** Where visitors reach it, or null while FileFreak serves no sites. */
+    address: string | null;
+    /** Whether a path with no file and no extension is served the site's /index.html, as an app that draws its own pages needs. */
+    singlePage: boolean;
+    /** What the site holds, across all its deploys, each file's bytes once. It counts as storage. */
+    storedBytes: number;
+    /** The deploy visitors are served, or null while the site is offline. */
+    live: SiteDeploy | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One deploy of a site: a set of files, kept as they were sent. */
+export interface SiteDeploy {
+    id: string;
+    /** 1 for a site's first deploy, and one more each time. */
+    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 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. */
+    sizeBytes: number;
+    /** Whether visitors to the site's address are served this deploy. */
+    live: boolean;
+    /** This deploy's own address, whichever deploy is live. Null until it is ready, and while FileFreak serves no sites. */
+    address: string | null;
+    createdAt: string;
+    /** When it became ready. */
+    finishedAt: string | null;
+}
+/** Where to send one file's bytes for a deploy. */
+export interface SendTo {
+    sha256: string;
+    sizeBytes: number;
+    method: "PUT";
+    /** PUT the file's bytes here, whole, as the body. No key: the address is the permission. */
+    url: string;
+    /** Headers the request must carry. */
+    headers: Record<string, string>;
+    /** 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). */
+    parent?: string;
+    /** nextCursor from the page before. */
+    cursor?: string;
+    /** How many to return, 1 to 200. */
+    limit?: number;
+};
+/** What GET /v1/files answers with. */
+export type FilesListAnswer = {
+    items: Array<Item>;
+    nextCursor: string | null;
+};
+/** What GET /v1/files/by-path takes in its query. */
+export type FilesByPathQuery = {
+    /** Such as Photos/2024/beach.jpg. */
+    path: string;
+};
+/** What GET /v1/files/by-path answers with. */
+export type FilesByPathAnswer = {
+    item: Item;
+};
+/** What GET /v1/files/:id answers with. */
+export type FilesGetAnswer = {
+    item: Item;
+};
+/** What PATCH /v1/files/:id takes as its body. */
+export type FilesUpdateBody = {
+    /** A new name. Refused with name_taken if the folder already has something called that. */
+    name?: string;
+    /** The folder to move it into, or null for the top of the app. */
+    parentId?: string | null;
+    /** public, private, or inherit to follow the folder it is in. */
+    visibility?: "private" | "public" | "inherit";
+};
+/** What PATCH /v1/files/:id answers with. */
+export type FilesUpdateAnswer = {
+    item: Item;
+};
+/** What DELETE /v1/files/:id takes in its query. */
+export type FilesDeleteQuery = {
+    /** true to delete for good instead of putting in the trash. */
+    permanent?: boolean;
+    /** Only if it is still at this revision. A file given new content since it was read is left alone, and the answer is 409 revision_changed: for a program keeping a copy, which must not remove a change it has not seen. */
+    ifRevision?: number;
+};
+/** What DELETE /v1/files/:id answers with. */
+export type FilesDeleteAnswer = Ok;
+/** What POST /v1/files/:id/restore answers with. */
+export type FilesRestoreAnswer = {
+    item: Item;
+};
+/** What POST /v1/folders takes as its body. */
+export type FoldersCreateBody = {
+    name: string;
+    /** The folder to make it in. Null, or left out, for the top of the app. */
+    parentId?: string | null;
+    /** What to do if the folder already has one of that name. */
+    ifExists?: "fail" | "use";
+};
+/** What POST /v1/folders answers with. */
+export type FoldersCreateAnswer = {
+    item: Item;
+};
+/** What GET /v1/tree takes in its query. */
+export type TreeListQuery = {
+    /** The folder to list under. Left out, the top of the app (or of the folder the key is confined to). */
+    parent?: string;
+    /** nextCursor from the page before. */
+    cursor?: string;
+    /** How many to return, 1 to 1000. */
+    limit?: number;
+};
+/** What GET /v1/tree answers with. */
+export type TreeListAnswer = {
+    items: Array<Item>;
+    nextCursor: string | null;
+    /** Where to follow GET /v1/changes from once every page has been read. */
+    changesCursor: string | null;
+};
+/** What GET /v1/changes takes in its query. */
+export type ChangesListQuery = {
+    /** cursor from the answer before, or changesCursor from GET /v1/tree. */
+    cursor?: string;
+    /** Seconds to wait for a change when there is none yet, 0 to 200. */
+    wait?: number;
+    /** How many changes to return, 1 to 1000. */
+    limit?: number;
+};
+/** What GET /v1/changes answers with. */
+export type ChangesListAnswer = {
+    changes: Array<Change>;
+    /** Where to ask from next time. */
+    cursor: string;
+    /** True when there are more changes already: ask again at once. */
+    more: boolean;
+};
+/** What POST /v1/uploads takes as its body. */
+export type UploadsBeginBody = {
+    name: string;
+    /** Exactly how many bytes will be sent. What arrives is measured, and that is what is counted. */
+    sizeBytes: number;
+    /** Left out, it is worked out from the name. */
+    contentType?: string;
+    /** The folder to put it in. Null, or left out, for the top of the app. */
+    parentId?: string | null;
+    /** What to do if the folder already has a file of that name. replace keeps the file's id and its public address. */
+    onConflict?: "rename" | "replace" | "fail";
+    /** Sizes to make of it, if it is an image, so they are ready when wanted: any of 64, 128, 256, 512, 1024. */
+    imageSizes?: Array<number>;
+    /** With onConflict replace: the file this is meant to replace, as you read it, by its id and revision. If the folder's file of that name is any other file, or this one at another revision, the upload is refused with 409 revision_changed, when it begins and again when it completes, and nothing is replaced. For a program keeping a copy, which must not write over a change it has not seen. */
+    replacing?: {
+        id: string;
+        revision: number;
+    };
+    /** How many bytes each part should be, from 8388608 (8 MiB) to 67108864 (64 MiB). Larger parts go faster on a fast line, because every request costs a round trip; smaller ones lose less when one fails on a slow line. Left out, a part is 8 MiB. A file so large that it would need more than 10,000 parts gets larger ones, and the answer's partBytes is what to cut it by. */
+    partBytes?: number;
+    /** Instead of partBytes: the file cut into blocks of your choosing, in order, each its size and SHA-256, adding up to sizeBytes. Up to 10000 blocks of up to 67108864 bytes (64 MiB). Each part is then one block. Cut where the content says (content-defined chunking), so that an edit changes few blocks, and an upload with onConflict replace sends only the blocks the file does not have already: those it has are copied inside storage, and listed in the answer's reused. Kept with the file, so its next replacement can do the same. The hashes are your word, as sha256 on completing is. */
+    blocks?: Array<{
+        /** How many bytes the block is. */
+        size: number;
+        /** The block's SHA-256 in hex. */
+        sha256: string;
+    }>;
+};
+/** What POST /v1/uploads answers with. */
+export type UploadsBeginAnswer = {
+    upload: Upload;
+    /** Addresses for the first parts to send. Parts listed in reused are not among them. */
+    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>;
+};
+/** What GET /v1/uploads/:id answers with. */
+export type UploadsGetAnswer = {
+    upload: Upload;
+    /** The numbers of the parts storage has, counting those it has without their being sent: what is left to send is every other part not in reused. */
+    uploadedParts: Array<number>;
+    /** The blocks the upload was begun with, in order, so each can be checked against the file before it is sent. Null for an upload cut by partBytes. */
+    blocks: Array<{
+        size: number;
+        sha256: string;
+    }> | null;
+    /** As in the answer that began the upload: the parts not to send. */
+    reused: Array<number>;
+};
+/** What GET /v1/uploads/:id/parts takes in its query. */
+export type UploadsPartsQuery = {
+    /** The first part wanted, counted from zero. */
+    from?: number;
+    count?: number;
+};
+/** What GET /v1/uploads/:id/parts answers with. */
+export type UploadsPartsAnswer = {
+    parts: Array<Part>;
+};
+/** 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. */
+    sha256?: string;
+};
+/** What POST /v1/uploads/:id/complete answers with. */
+export type UploadsCompleteAnswer = {
+    item: Item;
+} | Pending;
+/** What DELETE /v1/uploads/:id answers with. */
+export type UploadsCancelAnswer = Ok;
+/** What GET /v1/files/:id/download takes in its query. */
+export type FilesDownloadUrlQuery = {
+    /** true to have a browser show it, for the types that are safe to show. Anything else is saved, whatever is asked. */
+    inline?: boolean;
+};
+/** What GET /v1/files/:id/download answers with. */
+export type FilesDownloadUrlAnswer = {
+    url: string;
+    expiresAt: string;
+    /** Whether the address will show the file or save it. */
+    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. */
+    size: number;
+};
+/** What GET /v1/files/:id/image answers with. */
+export type FilesImageAnswer = {
+    status: "ready";
+    url: string;
+    width: number;
+    height: number;
+    expiresAt: string;
+} | {
+    status: "pending";
+    retryAfterSeconds: number;
+};
+/** What GET /v1/usage answers with. */
+export type UsageGetAnswer = {
+    app: {
+        storedBytes: number;
+        fileCount: number;
+        /** The ceiling set for this app, or null for none. */
+        storageCapBytes: number | null;
+        apiCallsThisMonth: number;
+    } | null;
+    account: {
+        plan: string;
+        storageUsedBytes: number;
+        storageIncludedBytes: number;
+        /** Where uploads are refused: what the plan includes, plus what the account's spending limit allows beyond it. */
+        storageLimitBytes: number;
+        downloadedBytesThisMonth: number;
+        downloadsIncludedBytes: number;
+        apiCallsThisMonth: number;
+        apiCallsIncluded: number;
+    };
+};
+/** 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 filefreak login. */
+    via: "key" | "token" | "device";
+    account: {
+        username: string;
+        /** For a device only. Null for a key and a token. */
+        email: string | null;
+        plan: string;
+    };
+    /** The app a key or a token acts for. Null for a device, which uses the personal drive. */
+    app: {
+        id: string;
+        name: string;
+    } | null;
+    /** The device, by the name it signed in with. Null for a key and a token. */
+    device: {
+        id: string;
+        name: string;
+    } | null;
+    /** What it may do. A device may do everything its person may. */
+    scopes: Array<"files:read" | "files:write" | "files:delete" | "usage:read">;
+    /** The folder it is kept to, or null for everything its app holds, or the whole drive for a device. */
+    folderId: string | null;
+};
+/** What POST /v1/shares takes as its body. */
+export type SharesCreateBody = {
+    /** The file or folder to open. */
+    itemId: string;
+    /** Asked for before anything is shown. */
+    password?: string | null;
+    /** Days from now. Left out, it does not end by date. */
+    expiresInDays?: number | null;
+    /** Left out, any number. */
+    maxDownloads?: number | null;
+};
+/** What POST /v1/shares answers with. */
+export type SharesCreateAnswer = {
+    share: Share;
+};
+/** What GET /v1/shares takes in its query. */
+export type SharesListQuery = {
+    /** Only the links on this file or folder. */
+    itemId?: string;
+};
+/** What GET /v1/shares answers with. */
+export type SharesListAnswer = {
+    shares: Array<Share>;
+};
+/** What DELETE /v1/shares/:id answers with. */
+export type SharesRevokeAnswer = Ok;
+/** What GET /v1/sites answers with. */
+export type SitesListAnswer = {
+    sites: Array<Site>;
+    /** How many sites the account's plan allows. 0 on a plan without sites. */
+    maxSites: number;
+    /** The domain sites are served under, or null while FileFreak serves none. */
+    domain: string | null;
+};
+/** What POST /v1/sites takes as its body. */
+export type SitesCreateBody = {
+    name: string;
+    /** Serve /index.html for a path with no file and no extension, as an app that draws its own pages needs. */
+    singlePage?: boolean;
+};
+/** What POST /v1/sites answers with. */
+export type SitesCreateAnswer = {
+    site: Site;
+};
+/** What GET /v1/sites/:id answers with. */
+export type SitesGetAnswer = {
+    site: Site;
+    deploys: Array<SiteDeploy>;
+};
+/** What POST /v1/sites/:id/deploys takes as its body. */
+export type SitesStartDeployBody = {
+    files: Array<{
+        /** Relative to the folder being deployed, with forward slashes: "index.html", "docs/a.html". */
+        path: string;
+        sizeBytes: number;
+        /** The file's SHA-256 in hex. Bytes the site has stored already, under this SHA-256, are not sent again. */
+        sha256: string;
+    }>;
+    /** True when further files will be declared with sites.declareFiles. */
+    more: boolean;
+};
+/** What POST /v1/sites/:id/deploys answers with. */
+export type SitesStartDeployAnswer = {
+    deploy: SiteDeploy;
+    /** The files whose bytes the site does not have yet, one for each SHA-256. Empty files are never in it: there is nothing to send. */
+    send: Array<SendTo>;
+};
+/** What POST /v1/sites/deploys/:id/files takes as its body. */
+export type SitesDeclareFilesBody = {
+    files: Array<{
+        /** Relative to the folder being deployed, with forward slashes: "index.html", "docs/a.html". */
+        path: string;
+        sizeBytes: number;
+        /** The file's SHA-256 in hex. Bytes the site has stored already, under this SHA-256, are not sent again. */
+        sha256: string;
+    }>;
+    /** False on the last list. */
+    more: boolean;
+};
+/** What POST /v1/sites/deploys/:id/files answers with. */
+export type SitesDeclareFilesAnswer = {
+    deploy: SiteDeploy;
+    /** The files whose bytes the site does not have yet, one for each SHA-256. Empty files are never in it: there is nothing to send. */
+    send: Array<SendTo>;
+};
+/** What POST /v1/sites/deploys/:id/send takes as its body. */
+export type SitesSendAgainBody = {
+    sha256: Array<string>;
+};
+/** What POST /v1/sites/deploys/:id/send answers with. */
+export type SitesSendAgainAnswer = {
+    send: Array<SendTo>;
+};
+/** What POST /v1/sites/deploys/:id/finish takes as its body. */
+export type SitesFinishDeployBody = {
+    /** Make it the deploy visitors are served. Left out, it is. */
+    live?: boolean;
+};
+/** What POST /v1/sites/deploys/:id/finish answers with. */
+export type SitesFinishDeployAnswer = {
+    deploy: SiteDeploy;
+} | Pending;
+/** What DELETE /v1/sites/deploys/:id answers with. */
+export type SitesRemoveDeployAnswer = Ok;
+/** What POST /v1/sites/:id/live takes as its body. */
+export type SitesSetLiveBody = {
+    deployId: string | null;
+};
+/** What POST /v1/sites/:id/live answers with. */
+export type SitesSetLiveAnswer = {
+    site: Site;
+};
+/** What POST /v1/tokens takes as its body. */
+export type TokensCreateBody = {
+    /** What the token may do, of what the key may. Left out, all the key may. */
+    scopes?: Array<"files:read" | "files:write" | "files:delete" | "usage:read">;
+    /** A folder to keep the token to: the key's own, or one inside it. Left out, everything the key reaches. */
+    folderId?: string | null;
+    /** How long it works, from 60 seconds to 3600. */
+    expiresInSeconds?: number;
+};
+/** What POST /v1/tokens answers with. */
+export type TokensCreateAnswer = {
+    /** Sent as a key is: Authorization: Bearer fft_... */
+    token: string;
+    expiresAt: string;
+    scopes: Array<"files:read" | "files:write" | "files:delete" | "usage:read">;
+    /** The folder it is kept to, or null for everything its key reaches. */
+    folderId: string | null;
+};
+export interface Operation {
+    method: "GET" | "POST" | "PATCH" | "DELETE";
+    /** With :id where an id goes. */
+    path: string;
+    /** An Idempotency-Key is honoured: the same request sent again with the same key makes nothing twice. */
+    idempotent: boolean;
+    /** Sending it again after no answer can do nothing twice, with no Idempotency-Key. */
+    repeatable: boolean;
+}
+/** Every endpoint, by the name its entry gives it. */
+export declare const OPERATIONS: {
+    readonly "files.list": {
+        readonly method: "GET";
+        readonly path: "/v1/files";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "files.byPath": {
+        readonly method: "GET";
+        readonly path: "/v1/files/by-path";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "files.get": {
+        readonly method: "GET";
+        readonly path: "/v1/files/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "files.update": {
+        readonly method: "PATCH";
+        readonly path: "/v1/files/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "files.delete": {
+        readonly method: "DELETE";
+        readonly path: "/v1/files/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "files.restore": {
+        readonly method: "POST";
+        readonly path: "/v1/files/:id/restore";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "folders.create": {
+        readonly method: "POST";
+        readonly path: "/v1/folders";
+        readonly idempotent: true;
+        readonly repeatable: false;
+    };
+    readonly "tree.list": {
+        readonly method: "GET";
+        readonly path: "/v1/tree";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "changes.list": {
+        readonly method: "GET";
+        readonly path: "/v1/changes";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "uploads.begin": {
+        readonly method: "POST";
+        readonly path: "/v1/uploads";
+        readonly idempotent: true;
+        readonly repeatable: false;
+    };
+    readonly "uploads.get": {
+        readonly method: "GET";
+        readonly path: "/v1/uploads/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "uploads.parts": {
+        readonly method: "GET";
+        readonly path: "/v1/uploads/:id/parts";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "uploads.complete": {
+        readonly method: "POST";
+        readonly path: "/v1/uploads/:id/complete";
+        readonly idempotent: false;
+        readonly repeatable: true;
+    };
+    readonly "uploads.cancel": {
+        readonly method: "DELETE";
+        readonly path: "/v1/uploads/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "files.downloadUrl": {
+        readonly method: "GET";
+        readonly path: "/v1/files/:id/download";
+        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";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "usage.get": {
+        readonly method: "GET";
+        readonly path: "/v1/usage";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "me.get": {
+        readonly method: "GET";
+        readonly path: "/v1/me";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "shares.create": {
+        readonly method: "POST";
+        readonly path: "/v1/shares";
+        readonly idempotent: true;
+        readonly repeatable: false;
+    };
+    readonly "shares.list": {
+        readonly method: "GET";
+        readonly path: "/v1/shares";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "shares.revoke": {
+        readonly method: "DELETE";
+        readonly path: "/v1/shares/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "sites.list": {
+        readonly method: "GET";
+        readonly path: "/v1/sites";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "sites.create": {
+        readonly method: "POST";
+        readonly path: "/v1/sites";
+        readonly idempotent: true;
+        readonly repeatable: false;
+    };
+    readonly "sites.get": {
+        readonly method: "GET";
+        readonly path: "/v1/sites/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "sites.startDeploy": {
+        readonly method: "POST";
+        readonly path: "/v1/sites/:id/deploys";
+        readonly idempotent: true;
+        readonly repeatable: false;
+    };
+    readonly "sites.declareFiles": {
+        readonly method: "POST";
+        readonly path: "/v1/sites/deploys/:id/files";
+        readonly idempotent: true;
+        readonly repeatable: false;
+    };
+    readonly "sites.sendAgain": {
+        readonly method: "POST";
+        readonly path: "/v1/sites/deploys/:id/send";
+        readonly idempotent: false;
+        readonly repeatable: true;
+    };
+    readonly "sites.finishDeploy": {
+        readonly method: "POST";
+        readonly path: "/v1/sites/deploys/:id/finish";
+        readonly idempotent: false;
+        readonly repeatable: true;
+    };
+    readonly "sites.removeDeploy": {
+        readonly method: "DELETE";
+        readonly path: "/v1/sites/deploys/:id";
+        readonly idempotent: false;
+        readonly repeatable: false;
+    };
+    readonly "sites.setLive": {
+        readonly method: "POST";
+        readonly path: "/v1/sites/:id/live";
+        readonly idempotent: false;
+        readonly repeatable: true;
+    };
+    readonly "tokens.create": {
+        readonly method: "POST";
+        readonly path: "/v1/tokens";
+        readonly idempotent: false;
+        readonly repeatable: true;
+    };
+};
+export type OperationName = keyof typeof OPERATIONS;
+/** What a function below hands the client: what goes in the address, the query and the body. */
+export interface Input {
+    params?: Record<string, string>;
+    query?: object | undefined;
+    body?: object | undefined;
+}
+export type Call = (operation: OperationName, input: Input, options?: CallOptions) => Promise<unknown>;
+/** Every endpoint as a function, grouped by what it is about. */
+export declare function bind(call: Call): {
+    files: {
+        /**
+         * List a folder.
+         *
+         * What is in a folder, a page at a time: folders first, then files, each by name. Pass nextCursor back as cursor for the next page; when it is null there is no more. Things in the trash are not listed. A page never repeats or skips something because of what was added or removed between two requests.
+         *
+         * GET /v1/files. Needs the scope files:read.
+         */
+        list: (query?: FilesListQuery, options?: CallOptions) => Promise<FilesListAnswer>;
+        /**
+         * A file or folder by its path.
+         *
+         * Found by the names of the folders down to it from the top of the app (or of the folder the key is confined to), separated by /. A name matches whatever its case, as names in one folder do. Nothing in the trash is found, nor anything inside something that is.
+         *
+         * GET /v1/files/by-path. Needs the scope files:read.
+         */
+        byPath: (query: FilesByPathQuery, options?: CallOptions) => Promise<FilesByPathAnswer>;
+        /**
+         * One file or folder.
+         *
+         * By its id. Something in the trash is still returned, with trashedAt set.
+         *
+         * GET /v1/files/:id. Needs the scope files:read.
+         */
+        get: (id: string, options?: CallOptions) => Promise<FilesGetAnswer>;
+        /**
+         * Rename, move, or make public.
+         *
+         * 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.
+         *
+         * PATCH /v1/files/:id. Needs the scope files:write.
+         */
+        update: (id: string, body: FilesUpdateBody, options?: CallOptions) => Promise<FilesUpdateAnswer>;
+        /**
+         * Put in the trash, or delete for good.
+         *
+         * Without permanent, the file or folder goes to the trash: it can be restored, it still counts toward storage, and it is removed for good after thirty days. With permanent=true it is removed now, with everything inside it, and cannot be brought back.
+         *
+         * DELETE /v1/files/:id. Needs the scope files:delete.
+         */
+        delete: (id: string, query?: FilesDeleteQuery, options?: CallOptions) => Promise<FilesDeleteAnswer>;
+        /**
+         * Take out of the trash.
+         *
+         * It goes back where it was. If that folder has gone it goes to the top, and if its name has been taken in the meantime it comes back with a number after it.
+         *
+         * POST /v1/files/:id/restore. Needs the scope files:write.
+         */
+        restore: (id: string, options?: CallOptions) => Promise<FilesRestoreAnswer>;
+        /**
+         * 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 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.
+         *
+         * A copy of an image no more than size pixels on its longest side, as WebP, with the camera's metadata removed. The sizes are 64, 128, 256, 512, 1024 and no others. Each is made once, the first time it is asked for, and kept: until it has been made the answer is 202. Name the sizes when the image is uploaded and they are ready by the time they are wanted. For a public file, add ?size= to its publicUrl. A file under Shard Protection has no smaller copies, and is answered with 409 shard_protected.
+         *
+         * GET /v1/files/:id/image. Needs the scope files:read.
+         */
+        image: (id: string, query: FilesImageQuery, options?: CallOptions) => Promise<FilesImageAnswer>;
+    };
+    folders: {
+        /**
+         * Make a folder.
+         *
+         * Folders can be nested up to 32 deep. With ifExists=use, a folder of that name that is already there is returned and nothing is made, which is what a program that makes its folders on every start wants.
+         *
+         * POST /v1/folders. Needs the scope files:write. Honours an Idempotency-Key.
+         */
+        create: (body: FoldersCreateBody, options?: CallOptions) => Promise<FoldersCreateAnswer>;
+    };
+    tree: {
+        /**
+         * Everything under a folder.
+         *
+         * Every file and folder under a folder, at every level, a page at a time, each folder before what is inside it. Pass nextCursor back as cursor for the next page; when it is null there is no more. Things in the trash are not listed. Every page carries changesCursor: the place in GET /v1/changes from before the first page was read. Something that changes while the pages are being read may be listed or not, and is in the changes after that place either way. It is null for a key confined to a folder, which cannot follow the changes.
+         *
+         * GET /v1/tree. Needs the scope files:read.
+         */
+        list: (query?: TreeListQuery, options?: CallOptions) => Promise<TreeListAnswer>;
+    };
+    changes: {
+        /**
+         * What has changed.
+         *
+         * Every change to the app's files and folders after cursor, oldest first, each saying what the thing is now. A folder's change stands for everything in it: a folder moved, put in the trash or deleted is one change, and what is inside goes with it. Without cursor, no changes and the cursor for now. Pass cursor back each time; while more is true, ask again at once. With wait, an answer that would be empty waits up to that many seconds for something to change, and comes back empty, with the same cursor, if nothing does.
+         *
+         * To keep a copy: list everything with GET /v1/tree and keep its changesCursor, then apply each change in order. A change that is not live, or whose parentId is a folder the copy does not have, takes that thing and everything inside it out of the copy. A live change puts it in, or moves or renames it; a folder that was not in the copy is then listed with GET /v1/tree?parent= for what it holds, and if that is answered 404 the folder has gone since, which a later change says. A file whose revision has gone up has new content. Changes are kept for 30 days, and a cursor from before that is answered 410 cursor_expired: start again from a listing. A key confined to a folder cannot follow the changes, and lists its folder again instead.
+         *
+         * While the service is asleep, after a while with nobody using it, nothing can change, and a question with a cursor is answered without waking it: no changes, the same cursor, after the wait asked for. Asking is not counted as using the service, so a program that asks all night does not keep it awake.
+         *
+         * GET /v1/changes. Needs the scope files:read.
+         */
+        list: (query?: ChangesListQuery, options?: CallOptions) => Promise<ChangesListAnswer>;
+    };
+    uploads: {
+        /**
+         * Begin an upload.
+         *
+         * Says what is about to be sent, and answers with where to send it. A file's bytes never pass through this API: they go straight to storage, in parts, each with a plain PUT to the address given for it. The first addresses come back here; ask for the rest as they are needed. Then complete the upload, and it becomes a file.
+         *
+         * 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 folder under Shard Protection, which its owner turns on from the website, a file lands as an ordinary file, as it would anywhere else, and the service protects it within a few minutes: its content, and every kept version, are spread over the storage lanes as fragments. Until then it can be read like any other file. From then on it is read through its map (files.shards), and its clientSha256 is null. An upload from a program is not sealed as it is sent yet.
+         *
+         * 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.
+         *
+         * GET /v1/uploads/:id. Needs the scope files:write.
+         */
+        get: (id: string, options?: CallOptions) => Promise<UploadsGetAnswer>;
+        /**
+         * 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.
+         *
+         * GET /v1/uploads/:id/parts. Needs the scope files:write.
+         */
+        parts: (id: string, query?: UploadsPartsQuery, options?: CallOptions) => Promise<UploadsPartsAnswer>;
+        /**
+         * Finish an upload.
+         *
+         * Turns the parts into a file. Safe to call again: a second call for an upload that has finished answers with the same file. For a very large file storage may still be putting it together, and the answer is then 202 with how long to wait before asking again.
+         *
+         * POST /v1/uploads/:id/complete. Needs the scope files:write. Safe to send again.
+         */
+        complete: (id: string, body?: UploadsCompleteBody, options?: CallOptions) => Promise<UploadsCompleteAnswer>;
+        /**
+         * Cancel an upload.
+         *
+         * Whatever had arrived is deleted, and the room it held comes back at once.
+         *
+         * DELETE /v1/uploads/:id. Needs the scope files:write.
+         */
+        cancel: (id: string, options?: CallOptions) => Promise<UploadsCancelAnswer>;
+    };
+    usage: {
+        /**
+         * 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 filefreak login, which uses the personal drive, app is null.
+         *
+         * GET /v1/usage. Needs the scope usage:read.
+         */
+        get: (options?: CallOptions) => Promise<UsageGetAnswer>;
+    };
+    me: {
+        /**
+         * 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 filefreak login, which is the person, is told that.
+         *
+         * GET /v1/me. Any key may call it.
+         */
+        get: (options?: CallOptions) => Promise<MeGetAnswer>;
+    };
+    shares: {
+        /**
+         * 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 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 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 filefreak login.
+         *
+         * 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 filefreak login.
+         *
+         * DELETE /v1/shares/:id. Only a device signed in with filefreak login may call it.
+         */
+        revoke: (id: string, options?: CallOptions) => Promise<SharesRevokeAnswer>;
+    };
+    sites: {
+        /**
+         * 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 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 filefreak login may call it.
+         */
+        list: (options?: CallOptions) => Promise<SitesListAnswer>;
+        /**
+         * Make a site.
+         *
+         * 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 filefreak login may call it. Honours an Idempotency-Key.
+         */
+        create: (body: SitesCreateBody, options?: CallOptions) => Promise<SitesCreateAnswer>;
+        /**
+         * A site and its deploys.
+         *
+         * 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 filefreak login may call it.
+         */
+        get: (id: string, options?: CallOptions) => Promise<SitesGetAnswer>;
+        /**
+         * Begin a deploy.
+         *
+         * 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 filefreak login may call it. Honours an Idempotency-Key.
+         */
+        startDeploy: (id: string, body: SitesStartDeployBody, options?: CallOptions) => Promise<SitesStartDeployAnswer>;
+        /**
+         * Declare more of a deploy's files.
+         *
+         * 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 filefreak login may call it. Honours an Idempotency-Key.
+         */
+        declareFiles: (id: string, body: SitesDeclareFilesBody, options?: CallOptions) => Promise<SitesDeclareFilesAnswer>;
+        /**
+         * Fresh addresses for a deploy's files.
+         *
+         * 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 filefreak login may call it. Safe to send again.
+         */
+        sendAgain: (id: string, body: SitesSendAgainBody, options?: CallOptions) => Promise<SitesSendAgainAnswer>;
+        /**
+         * Finish a deploy.
+         *
+         * 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 filefreak login may call it. Safe to send again.
+         */
+        finishDeploy: (id: string, body?: SitesFinishDeployBody, options?: CallOptions) => Promise<SitesFinishDeployAnswer>;
+        /**
+         * Cancel or delete a deploy.
+         *
+         * 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 filefreak login may call it.
+         */
+        removeDeploy: (id: string, options?: CallOptions) => Promise<SitesRemoveDeployAnswer>;
+        /**
+         * Choose the live deploy.
+         *
+         * 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 filefreak login may call it. Safe to send again.
+         */
+        setLive: (id: string, body: SitesSetLiveBody, options?: CallOptions) => Promise<SitesSetLiveAnswer>;
+    };
+    tokens: {
+        /**
+         * A token for a web page.
+         *
+         * A key belongs on a server, and one sent from a web page is refused, because anybody who opens the page can read it. A page that should reach this API itself, to upload straight from the browser or to list a folder, is given a token instead: the server makes one with its key and hands it to the page, which sends it as it would a key. A token may do what its key may, or less: the scopes asked for, inside the folder asked for, until it expires. It is checked against its key on every request, so revoking the key stops its tokens at once, and its calls count as the key's. Nothing about a token is kept, so making one is safe to send again. A token cannot make another. Once Pro has ended and a key can only read, it can still make tokens, which can only read too.
+         *
+         * POST /v1/tokens. Any key may call it. Safe to send again.
+         */
+        create: (body?: TokensCreateBody, options?: CallOptions) => Promise<TokensCreateAnswer>;
+    };
+};