@hyperframes/share 0.9.28-alpha.0 → 0.9.28

package/dist/sources/capture.d.mts

@@ -1,24 +0,0 @@
-/** A file's SHA-256 by path, size, time and inode, kept for the launch so a check after a focus reads no bytes.
- * Only a settled file's hash is kept. */
-export function hashMemo(now?: () => number): {
-    /** @param {Found} file */
-    get: (file: Found) => string | null;
-    /** @param {Found} file @param {string} sha256 */
-    set: (file: Found, sha256: string) => void;
-};
-/** The file's SHA-256, read through the handle `openListed` checked; null when the file is not the one listed, or its
- * bytes changed while being read. `root` is the project's real path; `resolve` finds a folder's real path.
- * @param {string} root @param {Found} file @param {typeof realpath} [resolve] */
-export function hashListedFile(root: string, file: Found, resolve?: typeof realpath): Promise<string | null>;
-/** Captures `root` (a project's real path). `memo` reuses hashes of unchanged files; a send should pass a fresh one.
- * @param {string} root @param {{ memo?: ReturnType<typeof hashMemo>, limits?: import("./types.js").Limits }} [options]
- * @returns {Promise<Capture>} */
-export function captureProject(root: string, { memo, limits }?: {
-    memo?: ReturnType<typeof hashMemo>;
-    limits?: import("./types.js").Limits;
-}): Promise<Capture>;
-export type CaptureProblem = import("./types.js").CaptureProblem;
-export type Found = import("./types.js").Found;
-export type Walk = import("./types.js").Walk;
-export type Capture = import("./types.js").Capture;
-import { realpath } from "node:fs/promises";

package/dist/sources/contract.d.mts

@@ -1,2 +0,0 @@
-/** A registry's parsed JSON. @param {string} name a file in contract/, such as "path-policy.json" @returns {any} */
-export function readContract(name: string): any;

package/dist/sources/errors.d.mts

@@ -1,24 +0,0 @@
-/** The typed error for a refusal: the envelope's code when it is one of the sync routes', else the status's.
- * @param {Response} reply @returns {Promise<SyncApiError>} */
-export function refusalOf(reply: Response): Promise<SyncApiError>;
-/** A sync route's refusal or failure. `status` is 0 when the server was never reached. */
-export class SyncApiError extends Error {
-    /** @param {SyncErrorKind} kind @param {{ status?: number, code?: string | null, param?: string | null,
-     *   requestId?: string | null, retryAfterMs?: number | null, detail?: string }} [about] */
-    constructor(kind: SyncErrorKind, about?: {
-        status?: number;
-        code?: string | null;
-        param?: string | null;
-        requestId?: string | null;
-        retryAfterMs?: number | null;
-        detail?: string;
-    });
-    kind: import("./types.js").SyncErrorKind;
-    status: number;
-    code: string | null;
-    param: string | null;
-    requestId: string | null;
-    retryAfterMs: number | null;
-    detail: string | null;
-}
-export type SyncErrorKind = import("./types.js").SyncErrorKind;

package/dist/sources/limits.d.mts

@@ -1,12 +0,0 @@
-/** The first limit broken, in the server's fixed order (file count, file size, project size, manifest size), with
- * the biggest files first; null when the push fits. @param {readonly { path: string, size: number }[]} files
- * @param {number} manifestBytes @param {Limits} [limits] @returns {import("./types.js").OverLimit | null} */
-export function overLimit(files: readonly {
-    path: string;
-    size: number;
-}[], manifestBytes: number, limits?: Limits): import("./types.js").OverLimit | null;
-/** @typedef {import("./types.js").Limits} Limits @typedef {import("./types.js").LimitName} LimitName */
-/** @type {Limits} */
-export const V1_LIMITS: Limits;
-export type Limits = import("./types.js").Limits;
-export type LimitName = import("./types.js").LimitName;

package/dist/sources/manifest.d.mts

@@ -1,23 +0,0 @@
-/** The canonical bytes of a valid document. @param {ManifestDocument} document */
-export function canonicalBytes(document: ManifestDocument): Buffer<ArrayBuffer>;
-/** Validates a manifest document as the server does; throws ManifestInvalid. @param {unknown} raw
- * @param {boolean} [stored] @returns {Manifest} */
-export function parseManifest(raw: unknown, stored?: boolean): Manifest;
-/** Stored manifest bytes, which must already be canonical so their hash is the snapshot's manifest_sha256.
- * @param {Uint8Array} body @returns {Manifest} */
-export function parseCanonicalManifest(body: Uint8Array): Manifest;
-export const ENTRYPOINT: "index.html";
-/** @typedef {import("./types.js").ManifestFile} ManifestFile @typedef {import("./types.js").Violation} Violation
- * @typedef {import("./types.js").ManifestDocument} ManifestDocument @typedef {import("./types.js").Manifest} Manifest */
-/** Why a manifest was refused; `code` is the first violation's, in the server's order. */
-export class ManifestInvalid extends Error {
-    /** @param {Violation[]} violations */
-    constructor(violations: Violation[]);
-    violations: import("./types.js").Violation[];
-    code: string;
-}
-export function parseStoredManifest(raw: unknown): Manifest;
-export type ManifestFile = import("./types.js").ManifestFile;
-export type Violation = import("./types.js").Violation;
-export type ManifestDocument = import("./types.js").ManifestDocument;
-export type Manifest = import("./types.js").Manifest;

package/dist/sources/pathPolicy.d.mts

@@ -1,25 +0,0 @@
-/** The first rule matching a path's folded spelling. @param {string} path @returns {PathRule} */
-export function classifyPath(path: string): PathRule;
-/** `path` unchanged when every client can store it and the policy lets it travel; throws PathViolation otherwise,
- * naming the first failing check in the registry's order. @param {string} path
- * @param {boolean} [stored] */
-export function validatePath(path: string, stored?: boolean): string;
-/** Refuses duplicates, and any two paths (or a path and a directory prefix) one filesystem would store as one name.
- * Each path must already pass validatePath. @param {readonly string[]} paths */
-export function checkInventoryPaths(paths: readonly string[]): void;
-/** Whether no file under folder `dir` can be listed, so a capture need not open it: its first matching rule
- * excludes the folder and all below it, and no include rule before that one can reach inside. @param {string} dir */
-export function excludedFolder(dir: string): boolean;
-/** @typedef {import("./types.js").PathRule} PathRule @typedef {import("./types.js").PolicyDocument} PolicyDocument */
-/** A path the policy refuses: `code` is the golden vectors' shared vocabulary, `rule` the excluding rule's id. */
-export class PathViolation extends Error {
-    /** @param {string} code @param {string} path @param {string} [rule] */
-    constructor(code: string, path: string, rule?: string);
-    code: string;
-    path: string;
-    rule: string | null;
-}
-export function prefiltered(name: string): boolean;
-export function skippedSymlink(path: string): boolean;
-export type PathRule = import("./types.js").PathRule;
-export type PolicyDocument = import("./types.js").PolicyDocument;

package/dist/sources/projectState.d.mts

@@ -1,9 +0,0 @@
-/** A predicate for the paths the project's render-outputs.json lists, and everything under them; none when the file
- * is missing or not version 1. @param {string} root @returns {Promise<(rel: string) => boolean>} */
-export function readRenderOutputs(root: string): Promise<(rel: string) => boolean>;
-/** An open agent turn (its history-turn.json exists) or a project lock whose holder still runs.
- * @param {string} root */
-export function settledState(root: string): Promise<{
-    agentTurnOpen: boolean;
-    projectLocked: boolean;
-}>;

package/dist/sources/store.d.mts

@@ -1,3 +0,0 @@
-/** Project-local state is excluded by the portable source policy. Account/root mismatches fail closed, including copied folders.
- * @returns {import("./adapterTypes.js").SourceStore} */
-export function createProjectShareSourceStore(): import("./adapterTypes.js").SourceStore;

package/dist/sources/transfer.d.mts

@@ -1,45 +0,0 @@
-/** PUTs bytes of `file` to a signed URL with exactly the headers the grant signed. Resolves once storage keeps them;
- * the bytes sent must hash to `sha256`, or it throws `changed` whatever storage answered.
- * @param {{ fetchImpl: typeof fetch, url: string, headers: Record<string, string>, file: string, path: string,
- *   start: number, length: number, sha256: string, signal: AbortSignal, onBytes?: (bytes: number) => void, stallMs?: number }} put */
-export function putRange(put: {
-    fetchImpl: typeof fetch;
-    url: string;
-    headers: Record<string, string>;
-    file: string;
-    path: string;
-    start: number;
-    length: number;
-    sha256: string;
-    signal: AbortSignal;
-    onBytes?: (bytes: number) => void;
-    stallMs?: number;
-}): Promise<void>;
-/** Each part's SHA-256 (parts of `partBytes`, the last one shorter) and the whole file's, in one read.
- * @param {string} file @param {number} size @param {number} partBytes @param {AbortSignal} signal */
-export function partDigests(file: string, size: number, partBytes: number, signal: AbortSignal): Promise<{
-    parts: string[];
-    whole: string;
-    complete: boolean;
-}>;
-/** Runs `work` over `items`, `limit` at a time. The first failure stops new work; the rest finish, then it throws.
- * @template T @param {readonly T[]} items @param {number} limit @param {(item: T) => Promise<void>} work */
-export function eachLimit<T>(items: readonly T[], limit: number, work: (item: T) => Promise<void>): Promise<void>;
-/** Why a transfer stopped. `expired`: the signed URL no longer works (ask for a new one). `exists`: a create-only PUT
- * found the object already written. `changed`: the file's bytes are not the ones captured. `unreadable`: the file
- * could not be read (a drive unplugged, a file deleted). `corrupt`: downloaded bytes do not hash to what was asked.
- * `transient`: the network or the store failed; the same request may be sent again. */
-export class TransferError extends Error {
-    /** @param {"expired" | "exists" | "changed" | "unreadable" | "corrupt" | "transient" | "refused"} kind
-     * @param {{ status?: number, path?: string }} [about] */
-    constructor(kind: "expired" | "exists" | "changed" | "unreadable" | "corrupt" | "transient" | "refused", about?: {
-        status?: number;
-        path?: string;
-    });
-    kind: "expired" | "refused" | "changed" | "unreadable" | "exists" | "corrupt" | "transient";
-    status: number;
-    path: string | null;
-}
-export function isAbort(error: unknown): boolean;
-export function realWait(ms: number, signal?: AbortSignal): Promise<undefined>;
-export function backoffMs(attempt: number, askedMs?: number | null, baseMs?: number, maxMs?: number): number;

package/dist/sources/types.d.ts

@@ -1,353 +0,0 @@
-export interface SyncTooBig {
-  limit: "file_count" | "file_size" | "project_size" | "manifest_size";
-  actual: number;
-  maximum: number;
-  biggest: { path: string; size: number }[];
-}
-
-/** A file that keeps a project from being captured; it is never left out silently. */
-export interface SyncCaptureProblem {
-  path: string;
-  problem: "symlink" | "special-file" | "unreadable" | "invalid-name" | "changed" | "no-entrypoint";
-  /** For `invalid-name`, the path policy's code (`reserved_name`, `path_collision`, ...). */
-  code?: string;
-}
-
-export interface ManifestFile {
-  path: string;
-  sha256: string;
-  size: number;
-}
-
-export interface ManifestDocument {
-  format_version: 1;
-  entrypoint: "index.html";
-  files: ManifestFile[];
-}
-
-/** A valid manifest: its document in canonical order, the canonical bytes and their SHA-256. */
-export interface Manifest {
-  document: ManifestDocument;
-  canonical: Buffer;
-  sha256: string;
-}
-
-export interface Violation {
-  code: string;
-  path?: string;
-  rule?: string;
-}
-
-export type LimitName = SyncTooBig["limit"];
-
-export interface Limits {
-  maxFiles: number;
-  maxFileBytes: number;
-  maxProjectBytes: number;
-  maxManifestBytes: number;
-}
-
-export type OverLimit = SyncTooBig;
-
-type ClientAction = "include" | "exclude" | "wait_then_exclude";
-
-export interface PathRule {
-  id: string;
-  regex: string;
-  client_action: ClientAction;
-  server_action: "allow" | "reject";
-}
-
-/** The fields of contract/path-policy.json this client reads. */
-export interface PolicyDocument {
-  policy_version: string;
-  stored_manifest: { legacy_agent_state_regex: string };
-  unicode: { version: string };
-  rules: PathRule[];
-  path: {
-    max_path_bytes: number;
-    max_segment_bytes: number;
-    forbidden_characters: string;
-    reserved_segment_regex: string;
-    canonical_spelling_roots: string[];
-  };
-  client_prefilter: { names: string[] };
-  client_symlinks: { skip_prefixes: string[] };
-}
-
-export type CaptureProblem = SyncCaptureProblem;
-
-/** What an owner workspace's plan allows composition sync, as the limits route answered it. `unread` when it could not
- * be read: `not-deployed` is a server without the route (a 404), and nothing is refused on an unread answer. */
-export type SyncLimitsRead =
-  | {
-      at: "read";
-      syncAllowed: boolean;
-      maxCompositions: number;
-      /** Live compositions in the workspace when it was read. */
-      compositions: number;
-      push: Limits;
-    }
-  | { at: "unread"; why: "not-deployed" | "offline" | "failed" };
-
-/** A file a capture lists, before hashing. */
-export interface Found {
-  path: string;
-  full: string;
-  size: number;
-  mtimeMs: number;
-  ino: number;
-  dev: number;
-}
-
-export interface Walk {
-  files: Found[];
-  problems: CaptureProblem[];
-  waiting: string[];
-  skippedLinks: string[];
-}
-
-export type Capture =
-  | {
-      at: "captured";
-      manifest: Manifest;
-      settled: { agentTurnOpen: boolean; projectLocked: boolean };
-      waiting: string[];
-      skippedLinks: string[];
-    }
-  | { at: "problems"; problems: CaptureProblem[] }
-  | { at: "too-big"; over: OverLimit };
-
-export type SyncErrorKind =
-  | "offline"
-  | "signed-out"
-  | "malformed"
-  | "not-enabled"
-  | "byok"
-  | "no-write-role"
-  | "forbidden"
-  | "composition-not-found"
-  | "not-found"
-  | "too-large"
-  | "reference-invalid"
-  | "upload-not-pending"
-  | "active-uploads-exceeded"
-  | "file-not-writable"
-  | "idempotency-key-reused"
-  | "request-in-progress"
-  | "snapshot-not-downloadable"
-  | "conflict-not-open"
-  | "download-expired"
-  | "invalid-parameter"
-  | "plan-required"
-  | "limit-reached"
-  | "rate-limited"
-  | "unavailable"
-  | "server-error"
-  | "refused";
-
-export interface Composition {
-  id: string;
-  spaceId: string;
-  title: string;
-  createdBy: string;
-  /** Null before the first publish. */
-  latestSnapshotId: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface Snapshot {
-  id: string;
-  compositionId: string;
-  baseSnapshotId: string | null;
-  publicationOutcome: "published" | "conflict_saved";
-  conflictedWithSnapshotId: string | null;
-  conflictState: "open" | "resolved" | "discarded" | null;
-  resolvedBySnapshotId: string | null;
-  createdBy: string;
-  createdByName?: string | null;
-  clientType: string;
-  summary: string | null;
-  summarySource: string;
-  manifestSha256: string;
-  createdAt: string;
-  /** Only with `include=manifest`, and only once its bytes hash to manifestSha256. */
-  manifest: Manifest | null;
-}
-
-type UploadStatus = "pending" | "verifying" | "completed" | "failed" | "expired";
-
-export interface UploadReceipt {
-  uploadId: string;
-  compositionId: string;
-  snapshotId: string;
-  status: UploadStatus;
-  /** Why a failed upload failed: cancelled, content_incomplete, verification_timeout, access_revoked. */
-  errorCode: string | null;
-  baseSnapshotId: string | null;
-  resolvesConflictSnapshotIds: string[];
-  manifestSha256: string;
-  uploadDeadline: string;
-  verificationDeadline: string | null;
-  completedAt: string | null;
-  result: {
-    snapshotId: string;
-    publicationOutcome: "published" | "conflict_saved";
-    conflictedWithSnapshotId: string | null;
-  } | null;
-}
-
-interface BlobRef {
-  sha256: string;
-  size: number;
-}
-
-export interface BeginResult extends UploadReceipt {
-  /** Already saved in the base or a named conflict: never uploaded. */
-  present: BlobRef[];
-  /** To upload through upload-urls before submitting. */
-  needed: BlobRef[];
-  /** False for a replay of the same push under the same Idempotency-Key. */
-  created: boolean;
-}
-
-export interface BeginRequest {
-  idempotencyKey: string;
-  baseSnapshotId: string | null;
-  resolvesConflictSnapshotIds: string[];
-  summary: { text: string; source: "user" | "agent" } | null;
-  manifest: Manifest;
-}
-
-interface PartGrant {
-  partNumber: number;
-  length: number;
-  url: string;
-  headers: Record<string, string>;
-}
-
-export interface FileGrant {
-  sha256: string;
-  size: number;
-  expiresAt: string;
-  /** Files up to 64 MiB: one PUT. */
-  url: string | null;
-  headers: Record<string, string>;
-  /** Files over 64 MiB: the file's one multipart upload, and the requested parts. */
-  multipartUploadId: string | null;
-  parts: PartGrant[];
-}
-
-export interface GrantRequest {
-  sha256: string;
-  multipartUploadId?: string;
-  parts?: { partNumber: number; sha256: string }[];
-}
-
-export interface DownloadBatch {
-  snapshotId: string;
-  manifestSha256: string;
-  continuationToken: string;
-  continuationExpiresAt: string;
-  urls: { sha256: string; size: number; url: string; expiresAt: string }[];
-}
-
-export interface Page<T> {
-  items: T[];
-  nextToken: string | null;
-}
-
-export type CompositionRead =
-  | { at: "fresh"; composition: Composition; etag: string | null }
-  | { at: "unchanged"; etag: string };
-
-/** Whose binding: the backend's API host, the signed-in account (accountPrincipal) and the project's real path. */
-export interface BindingKey {
-  backend: string;
-  account: string;
-  projectPath: string;
-}
-
-/** A push recorded before its Begin is sent, so a lost answer is recovered by sending the same body under the same
- * Idempotency-Key; the upload's ids and deadlines land once an answer comes back. */
-export interface InflightUpload {
-  idempotencyKey: string;
-  baseSnapshotId: string | null;
-  resolvesConflictSnapshotIds: string[];
-  summary: { text: string; source: "user" | "agent" } | null;
-  manifest: ManifestDocument;
-  manifestSha256: string;
-  uploadId: string | null;
-  snapshotId: string | null;
-  uploadDeadline: string | null;
-  verificationDeadline: string | null;
-  begunAt: number;
-  /** Files whose bytes reached staging, by SHA-256, so a resumed send does not write them again. */
-  sent?: string[];
-  /** Each multipart file's pinned upload and the parts already written, by the file's SHA-256. */
-  multipart?: Record<string, { uploadId: string; partsDone: number[] }>;
-}
-
-export interface Binding extends BindingKey {
-  version: 1;
-  /** Client-generated, kept before the first request so a retried create names the same composition. */
-  compositionId: string;
-  ownerSpaceId: string;
-  /** The owner workspace as the account's list last named it, so a project whose workspace the account left can
-   * still be named. Absent from bindings made before it was kept, and until a list names the workspace. */
-  owner?: { name: string; kind: "personal" | "team" };
-  boundAt: number;
-  /** The composition as last read, and the ETag it came with; null before the create was answered. */
-  composition: Composition | null;
-  etag: string | null;
-  /** The snapshot this copy was last sent as or got from, with its manifest, so local changes need no network. */
-  base: { snapshotId: string; manifest: ManifestDocument; manifestSha256: string } | null;
-  inflight: InflightUpload | null;
-  /** Set while Get from the cloud is filling a folder it made, until the folder is added to Home. Until then the
-   * folder is not a project on this Mac, and the next Get of the composition finishes it. */
-  gettingFromCloud?: true;
-  /** What the marker that Get put in its folder holds: the only proof a file of that name there is not the person's. */
-  getToken?: string;
-  /** Set on the folder a Duplicate fills from the cloud: it is bound only while it downloads, so no Get ever opens
-   * it, and its binding goes once latest is in (duplicate.mjs). */
-  duplicate?: true;
-  /** The conflicts this Mac's sends saved, newest last: Compare names them as this project's, not another
-   * computer's. */
-  savedHere?: string[];
-  /** Set on a binding Work on {owner}'s project made from a share: the account reaches the owner's workspace through
-   * that share's grant, not membership, so every request names the review project (sync-backed sharing C5). */
-  sharedFrom?: SharedFrom;
-}
-
-/** The share a binding came from: its review project, the owner's name and their workspace's, as the share named
- * them when it was opened. */
-export interface SharedFrom {
-  reviewProjectId: string;
-  owner: string;
-  workspace: string | null;
-}
-
-/** A workspace's last refusal of a new composition: not admitted to sync yet, or encrypted (BYOK). */
-export interface SpaceRefusal {
-  kind: "not-enabled" | "byok";
-  at: number;
-}
-
-/** One send or get under way for a project: the binding it owns until it ends, and where its states go. */
-export interface UploadJob {
-  api: import("./api.mjs").SourceApi;
-  space: string;
-  composition: string;
-  uploadId: string;
-  inflight: InflightUpload;
-  local: Map<string, { path: string; full: string }>;
-  needed: { sha256: string; size: number }[];
-  fetchImpl: typeof fetch;
-  wait: (ms: number, signal?: AbortSignal) => Promise<void>;
-  signal: AbortSignal;
-  now: () => number;
-  persist: () => void;
-  onBytes: (bytes: number) => void;
-  onFile: () => void;
-}

package/dist/sources/unicode.d.mts

@@ -1,15 +0,0 @@
-/** Whether every code point is assigned in Unicode 15.1. @param {string} value */
-export function allAssigned(value: string): boolean;
-/** The spelling two names share on a case-insensitive or normalizing filesystem: NFC(casefold(NFC(value))).
- * @param {string} value */
-export function comparisonKey(value: string): string;
-export const UNICODE_VERSION: "15.1.0";
-export function nfc(value: string): string;
-export type UnicodeTableFile = {
-    unicode_version: string;
-    casefold: Record<string, string>;
-    combining: Record<string, number>;
-    decomposition: Record<string, number[]>;
-    composition: Record<string, number>;
-    assigned_ranges: [number, number][];
-};

package/dist/sources/upload.d.mts

@@ -1,9 +0,0 @@
-/** Resolve an older capture before starting an upload for the current files.
- * @param {SourceUpload} job @returns {Promise<import("./adapterTypes.js").SourceResult | null>} */
-export function recoverSourceUpload(job: SourceUpload): Promise<import("./adapterTypes.js").SourceResult | null>;
-/** Only published verification results can become share source; conflict_saved is preserved for explicit recovery.
- * @param {SourceRun} run @returns {Promise<import("./adapterTypes.js").SourceResult>} */
-export function uploadSource(run: SourceRun): Promise<import("./adapterTypes.js").SourceResult>;
-export type SourceRun = import("./adapterTypes.js").SourceRun;
-export type SourceUpload = Pick<SourceRun, "binding" | "api" | "store">;
-export type UploadReceipt = import("./types.js").UploadReceipt;

package/dist/sources/uploadFiles.d.mts

@@ -1,31 +0,0 @@
-/** Writes every needed file the in-flight record does not list as sent. @param {UploadJob} job */
-export function uploadNeeded(job: UploadJob): Promise<void>;
-/** The file's multipart upload can take no more parts (`hyperframes_composition_upload_file_not_writable`): this
- * upload cannot finish, so its owner must resolve it before a retry can begin a new one. */
-export class NotWritable extends Error {
-    constructor();
-}
-export type UploadJob = import("./types.js").UploadJob;
-export type Signed = {
-    url: string;
-    headers: Record<string, string>;
-    expiresAt: string;
-};
-export type Part = {
-    number: number;
-    sha256: string;
-    start: number;
-    length: number;
-};
-export type Bytes = {
-    file: {
-        path: string;
-        full: string;
-    };
-    start: number;
-    length: number;
-    sha256: string;
-};
-export type FileGrant = import("./types.js").FileGrant;
-export type GrantRequest = import("./types.js").GrantRequest;
-export type InflightUpload = import("./types.js").InflightUpload;

package/dist/sources/wire.d.mts

@@ -1,21 +0,0 @@
-/** @param {unknown} value @param {string} field @returns {Record<string, unknown>} */
-export function objectOf(value: unknown, field: string): Record<string, unknown>;
-/** @param {unknown} raw @returns {Composition} */
-export function compositionOf(raw: unknown): Composition;
-/** @param {unknown} raw @returns {Snapshot} */
-export function snapshotOf(raw: unknown): Snapshot;
-/** @param {unknown} raw @returns {UploadReceipt} */
-export function uploadOf(raw: unknown): UploadReceipt;
-/** @param {unknown} raw @returns {Extract<SyncLimitsRead, { at: "read" }>} */
-export function syncLimitsOf(raw: unknown): Extract<SyncLimitsRead, {
-    at: "read";
-}>;
-export function beginOf(raw: unknown, created: boolean): BeginResult;
-export function grantsOf(raw: unknown): FileGrant[];
-export type SyncLimitsRead = import("./types.js").SyncLimitsRead;
-export type Composition = import("./types.js").Composition;
-export type Snapshot = import("./types.js").Snapshot;
-export type UploadReceipt = import("./types.js").UploadReceipt;
-export type BeginResult = import("./types.js").BeginResult;
-export type FileGrant = import("./types.js").FileGrant;
-export type DownloadBatch = import("./types.js").DownloadBatch;