@elaraai/e3-cloud-types 1.0.94 → 1.0.97

package/dist/src/files-types.d.ts

@@ -4,23 +4,42 @@
  */
 /**
  * Files: a solution's inputs that come from files in a bucket, as East
- * values.
+ * values; and a record's seed, and a record's mutation fed, from
+ * files.
  *
  * A solution declares, with `@elaraai/e3-cloud-files`, which of its inputs a
  * source's files fill: one file, the newest under a prefix, every file under
- * a prefix, or a listing of them ({@link FilesShapeType}). The declarations
- * are a {@link FilesManifestType}, deployed beside the package and checked
+ * a prefix, or a listing of them ({@link FilesShapeType}); a `file` or
+ * `latest` shape may name a **type**, and the file is then taken in as the
+ * beast2 value it holds rather than as a `Blob`. What a mapping fills is its
+ * **target** ({@link FilesTargetType}): an input, a record (the file is the
+ * record's state: its genesis, then a seed again), or a record's mutation
+ * (each new file is the mutation's one argument). The declarations are a
+ * {@link FilesManifestType}, deployed beside the package and checked
  * against it. Each workspace binds a source to where its files are
  * ({@link FilesBindingType}); a sync brings in what changed and answers a
- * {@link FilesSyncReportType}. The checks answer {@link FilesProblemType}s,
- * each rendered as a line by {@link filesProblemText}.
+ * {@link FilesSyncReportType}; a push ({@link FilesPushRequestType}) puts
+ * files from disk into a source and syncs their targets. The checks answer
+ * {@link FilesProblemType}s, each rendered as a line by
+ * {@link filesProblemText}.
  *
- * A file arrives as it is, a `Blob`: nothing here parses it.
+ * A file with no type arrives as it is, a `Blob`: nothing here parses it. A
+ * typed file is beast2, whose root type must be the mapping's.
+ *
+ * @remarks
+ * WIRE COMPAT: the manifest, the reports, the ledgers and a sync's job are
+ * stored (the platform's `FILES/`, `FILESJOB/` and `RELEASE/` items and its
+ * `files-sync/` objects; a local repository's `.e3-cloud/files/<ws>.json`).
+ * Their first version (a mapping by `input`, a refusal's reason a string) is
+ * read through
+ * `@elaraai/e3-cloud-files/compat`, which keeps the first version's types
+ * and lifts a value into these; every store writes these. The API's own
+ * request and response types ship with the client and CLI.
  */
-import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type ValueTypeOf } from '@elaraai/east';
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastTypeValue, type ValueTypeOf } from '@elaraai/east';
 /**
- * The largest file `file` and `latest` take: beast2's largest frame, 1 GiB,
- * less the room its encoding takes (1 GiB less 64 KiB).
+ * The largest file `file` and `latest` take as a `Blob`: beast2's largest
+ * frame, 1 GiB, less the room its encoding takes (1 GiB less 64 KiB).
  */
 export declare const FILES_FILE_MAX_BYTES: number;
 /**
@@ -28,6 +47,22 @@ export declare const FILES_FILE_MAX_BYTES: number;
  * the room its path and lengths take (64 MiB less 64 KiB).
  */
 export declare const FILES_FOLDER_ENTRY_MAX_BYTES: number;
+/**
+ * The largest typed file whose value is no collection, and the largest file
+ * a mutation is fed: beast2's largest frame, 1 GiB, which a sandbox holds
+ * whole. A typed collection has no limit but its segments'.
+ */
+export declare const FILES_TYPED_VALUE_MAX_BYTES: number;
+/**
+ * The largest segment of a typed collection: beast2's, 64 MiB. A file
+ * written with a larger one is refused, naming the fix (write it again
+ * with a current writer).
+ */
+export declare const FILES_SEGMENT_MAX_BYTES: number;
+/** The most files one push plans. */
+export declare const FILES_PUSH_MAX_FILES = 1000;
+/** The part a push's multipart upload is cut in, and the most one PUT sends: 64 MiB. */
+export declare const FILES_PUSH_PART_BYTES: number;
 /** A file's row in a `listing` input. */
 export declare const FilesListingRowType: StructType<{
     /** Its size in bytes */
@@ -39,7 +74,7 @@ export declare const FilesListingRowType: StructType<{
 }>;
 export type FilesListingRowType = typeof FilesListingRowType;
 export type FilesListingRow = ValueTypeOf<typeof FilesListingRowType>;
-/** The input type of a `file` or `latest` mapping: the file's bytes. */
+/** The input type of a `file` or `latest` mapping with no type: the file's bytes. */
 export declare const FilesFileType: BlobType;
 /** The input type of a `folder` mapping: each file's path, relative to the prefix, to its bytes. */
 export declare const FilesFolderType: DictType<StringType, BlobType>;
@@ -56,9 +91,10 @@ export declare const FilesListingType: DictType<StringType, StructType<{
  * What a mapping selects from its source, relative to where the workspace
  * binds the source.
  *
- * - `file`: one key, as a `Blob`.
+ * - `file`: one key. As a `Blob`, or, with `type`, as the beast2 value of
+ *   that type the file holds.
  * - `latest`: the greatest key under a prefix that matches `include`, as a
- *   `Blob`.
+ *   `Blob` or, with `type`, as the value it holds.
  * - `folder`: every key under a prefix that matches `include`, as a
  *   `Dict<String, Blob>` keyed by its path relative to the prefix.
  * - `listing`: the same keys' sizes, times and ETags, without their bytes.
@@ -67,14 +103,102 @@ export declare const FilesListingType: DictType<StringType, StructType<{
  * within one segment of the path, `**` across segments, `?` one character,
  * `[abc]`, `[a-z]` and `[!abc]` one character of a set, and `{csv,json}` any
  * of its alternatives, each a glob itself.
+ *
+ * A record's or a mutation's mapping selects one file (`file` or `latest`)
+ * and names its type: the record's state type, or the mutation's one
+ * argument's.
  */
 export declare const FilesShapeType: VariantType<{
     readonly file: StructType<{
         readonly key: StringType;
+        readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
     }>;
     readonly latest: StructType<{
         readonly prefix: StringType;
         readonly include: OptionType<StringType>;
+        readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
     }>;
     readonly folder: StructType<{
         readonly prefix: StringType;
@@ -87,19 +211,160 @@ export declare const FilesShapeType: VariantType<{
 }>;
 export type FilesShapeType = typeof FilesShapeType;
 export type FilesShape = ValueTypeOf<typeof FilesShapeType>;
-/** One input a source's files fill. */
-export declare const FilesMappingType: StructType<{
-    /** The input's name: the dataset `.inputs.<input>` */
+/**
+ * What a mapping fills.
+ *
+ * - `input`: the dataset `.inputs.<name>`.
+ * - `record`: the record `.records.<name>`, seeded: its file is its first
+ *   state (its genesis), and a changed file its state again while nothing
+ *   has mutated it since.
+ * - `mutation`: one of a record's mutations, fed: each new file is the
+ *   mutation's one argument, applied once.
+ */
+export declare const FilesTargetType: VariantType<{
     readonly input: StringType;
+    readonly record: StringType;
+    readonly mutation: StructType<{
+        readonly record: StringType;
+        readonly mutation: StringType;
+    }>;
+}>;
+export type FilesTargetType = typeof FilesTargetType;
+export type FilesTarget = ValueTypeOf<typeof FilesTargetType>;
+/** Whether two targets are the same. */
+export declare const sameFilesTarget: (a: FilesTarget, b: FilesTarget) => boolean;
+/**
+ * A target as one text: `orders`, `record:customers`,
+ * `mutation:prices.load_prices`. What the CLI takes (`--as`, `--target`) and
+ * prints, and what {@link parseFilesTarget} reads back.
+ *
+ * @param target - The target
+ * @returns Its text
+ */
+export declare function filesTargetText(target: FilesTarget): string;
+/**
+ * A target, from its text ({@link filesTargetText}): a bare name is an
+ * input's. A mutation's text is split at its last dot (e3 lets a name hold
+ * one): a record's name may hold a dot, and a mutation whose name holds one
+ * cannot be named in this form, only as a structured target (a sync
+ * request's `targets`).
+ *
+ * @param text - `name`, `input:name`, `record:name` or `mutation:record.name`
+ * @returns The target, or null for text of another form
+ */
+export declare function parseFilesTarget(text: string): FilesTarget | null;
+/**
+ * A target in words: `input orders`, `record customers`,
+ * `mutation load_prices of customers`.
+ *
+ * @param target - The target
+ * @returns The words
+ */
+export declare function filesTargetWords(target: FilesTarget): string;
+/** One target a source's files fill. */
+export declare const FilesMappingType: StructType<{
+    /** What the files fill */
+    readonly target: VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>;
     /** The source's name */
     readonly source: StringType;
     readonly shape: VariantType<{
         readonly file: StructType<{
             readonly key: StringType;
+            readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>>;
         }>;
         readonly latest: StructType<{
             readonly prefix: StringType;
             readonly include: OptionType<StringType>;
+            readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>>;
         }>;
         readonly folder: StructType<{
             readonly prefix: StringType;
@@ -113,80 +378,626 @@ export declare const FilesMappingType: StructType<{
 }>;
 export type FilesMappingType = typeof FilesMappingType;
 export type FilesMapping = ValueTypeOf<typeof FilesMappingType>;
-/** A solution's declarations: its sources, and the inputs they fill. */
+/** A solution's declarations: its sources, and the targets they fill. */
 export declare const FilesManifestType: StructType<{
     /** The sources' names, in the order they were declared */
     readonly sources: ArrayType<StringType>;
     /** The mappings, in the order they were declared */
     readonly mappings: ArrayType<StructType<{
-        /** The input's name: the dataset `.inputs.<input>` */
-        readonly input: StringType;
+        /** What the files fill */
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
         /** The source's name */
         readonly source: StringType;
         readonly shape: VariantType<{
             readonly file: StructType<{
                 readonly key: StringType;
+                readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>>;
             }>;
             readonly latest: StructType<{
                 readonly prefix: StringType;
                 readonly include: OptionType<StringType>;
-            }>;
-            readonly folder: StructType<{
-                readonly prefix: StringType;
-                readonly include: OptionType<StringType>;
-            }>;
-            readonly listing: StructType<{
-                readonly prefix: StringType;
-                readonly include: OptionType<StringType>;
-            }>;
-        }>;
-    }>>;
-}>;
-export type FilesManifestType = typeof FilesManifestType;
-export type FilesManifest = ValueTypeOf<typeof FilesManifestType>;
-/**
- * Where one source's files are, for one workspace.
- *
- * `url` is `s3://bucket/prefix/`; a mapping's keys and prefixes are relative
- * to it. `region`, when the bucket's region is not the reader's own. On a
- * local repository only: `profile`, the cloud profile to read with, and
- * `latest`, which keeps only that many of each `folder`'s greatest keys.
- */
-export declare const FilesBindingType: StructType<{
-    readonly source: StringType;
-    readonly url: StringType;
-    readonly region: OptionType<StringType>;
+                readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>>;
+            }>;
+            readonly folder: StructType<{
+                readonly prefix: StringType;
+                readonly include: OptionType<StringType>;
+            }>;
+            readonly listing: StructType<{
+                readonly prefix: StringType;
+                readonly include: OptionType<StringType>;
+            }>;
+        }>;
+    }>>;
+}>;
+export type FilesManifestType = typeof FilesManifestType;
+export type FilesManifest = ValueTypeOf<typeof FilesManifestType>;
+/**
+ * Where one source's files are, for one workspace.
+ *
+ * `url` is `s3://bucket/prefix/`; a mapping's keys and prefixes are relative
+ * to it. `region`, when the bucket's region is not the reader's own. On a
+ * local repository only: `profile`, the cloud profile to read with, and
+ * `latest`, which keeps only that many of each `folder`'s greatest keys.
+ */
+export declare const FilesBindingType: StructType<{
+    readonly source: StringType;
+    readonly url: StringType;
+    readonly region: OptionType<StringType>;
     readonly profile: OptionType<StringType>;
     readonly latest: OptionType<IntegerType>;
 }>;
 export type FilesBindingType = typeof FilesBindingType;
 export type FilesBinding = ValueTypeOf<typeof FilesBindingType>;
+/**
+ * Why a sync did not take a file.
+ *
+ * - `too_large`: over its shape's limit, in bytes.
+ * - `segment_too_large`: a typed collection written with a segment over
+ *   beast2's 64 MiB; written again with a current writer, it is taken.
+ * - `unreadable`: the source would not give it (archived, changed since it
+ *   was listed, closed to the reader).
+ * - `not_beast2`: a typed mapping's file that is no beast2 container.
+ * - `type_mismatch`: a typed mapping's file holding a value of another
+ *   type than the mapping's.
+ * - `mutation`: a feed the mutation did not commit: its outcome
+ *   (`invalid`, `timed_out`, `failed`) and what it said; tried again once
+ *   the file changes.
+ * - `missing`: the file the mapping names is not there.
+ * - `other`: a reason stored before these were told apart.
+ */
+export declare const FilesRefusalReasonType: VariantType<{
+    readonly too_large: StructType<{
+        readonly size: IntegerType;
+        readonly limit: IntegerType;
+    }>;
+    readonly segment_too_large: StructType<{
+        readonly bytes: IntegerType;
+        readonly limit: IntegerType;
+    }>;
+    readonly unreadable: StringType;
+    readonly not_beast2: StringType;
+    readonly type_mismatch: StructType<{
+        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    readonly mutation: StructType<{
+        readonly outcome: StringType;
+        readonly message: StringType;
+    }>;
+    readonly missing: StringType;
+    readonly other: StringType;
+}>;
+export type FilesRefusalReasonType = typeof FilesRefusalReasonType;
+export type FilesRefusalReason = ValueTypeOf<typeof FilesRefusalReasonType>;
 /** A file a sync did not take, and why. */
 export declare const FilesRefusalType: StructType<{
     readonly key: StringType;
-    readonly reason: StringType;
+    readonly reason: VariantType<{
+        readonly too_large: StructType<{
+            readonly size: IntegerType;
+            readonly limit: IntegerType;
+        }>;
+        readonly segment_too_large: StructType<{
+            readonly bytes: IntegerType;
+            readonly limit: IntegerType;
+        }>;
+        readonly unreadable: StringType;
+        readonly not_beast2: StringType;
+        readonly type_mismatch: StructType<{
+            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly mutation: StructType<{
+            readonly outcome: StringType;
+            readonly message: StringType;
+        }>;
+        readonly missing: StringType;
+        readonly other: StringType;
+    }>;
 }>;
+export type FilesRefusalType = typeof FilesRefusalType;
 export type FilesRefusal = ValueTypeOf<typeof FilesRefusalType>;
-/** What one sync did for one mapping. */
-export declare const FilesMappingReportType: StructType<{
-    readonly input: StringType;
-    /** Files new since the last sync */
-    readonly added: IntegerType;
-    /** Files whose bytes changed */
+/** A typed file a sync took in: the value it holds. */
+export declare const FilesTakenType: StructType<{
+    /** The file's key */
+    readonly key: StringType;
+    /** The value's type: the mapping's */
+    readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    /** The collection's rows, where the store counts them */
+    readonly rows: OptionType<IntegerType>;
+    /** `carried` whole, or `split` into pieces by intake units */
+    readonly how: VariantType<{
+        readonly carried: NullType;
+        readonly split: NullType;
+    }>;
+}>;
+export type FilesTakenType = typeof FilesTakenType;
+export type FilesTaken = ValueTypeOf<typeof FilesTakenType>;
+/** What one sync did for one mapping. */
+export declare const FilesMappingReportType: StructType<{
+    readonly target: VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>;
+    /** Files new since the last sync */
+    readonly added: IntegerType;
+    /** Files whose bytes changed */
     readonly changed: IntegerType;
     /** Files gone from the source */
     readonly removed: IntegerType;
     /** Files as they were */
     readonly unchanged: IntegerType;
-    /** Files not taken: too large, or unreadable */
+    /** Files not taken, and why */
     readonly refused: ArrayType<StructType<{
         readonly key: StringType;
-        readonly reason: StringType;
+        readonly reason: VariantType<{
+            readonly too_large: StructType<{
+                readonly size: IntegerType;
+                readonly limit: IntegerType;
+            }>;
+            readonly segment_too_large: StructType<{
+                readonly bytes: IntegerType;
+                readonly limit: IntegerType;
+            }>;
+            readonly unreadable: StringType;
+            readonly not_beast2: StringType;
+            readonly type_mismatch: StructType<{
+                readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly mutation: StructType<{
+                readonly outcome: StringType;
+                readonly message: StringType;
+            }>;
+            readonly missing: StringType;
+            readonly other: StringType;
+        }>;
     }>>;
     /** The bytes taken in */
     readonly bytes: IntegerType;
-    /** Whether the input's value changed */
+    /** Whether the target's value changed */
     readonly updated: BooleanType;
+    /** The typed value taken in, for a typed mapping that took its file */
+    readonly taken: OptionType<StructType<{
+        /** The file's key */
+        readonly key: StringType;
+        /** The value's type: the mapping's */
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        /** The collection's rows, where the store counts them */
+        readonly rows: OptionType<IntegerType>;
+        /** `carried` whole, or `split` into pieces by intake units */
+        readonly how: VariantType<{
+            readonly carried: NullType;
+            readonly split: NullType;
+        }>;
+    }>>;
+    /** The commit a seed or a feed made: `$init`, `$seed`, or the mutation's */
+    readonly commit: OptionType<StringType>;
+    /** Why a seed was not applied: the record has been mutated since its seed */
+    readonly kept: OptionType<StringType>;
+    /** Why a feed waits: its record has no state yet; tried again by the next sync */
+    readonly waiting: OptionType<StringType>;
 }>;
 export type FilesMappingReportType = typeof FilesMappingReportType;
 export type FilesMappingReport = ValueTypeOf<typeof FilesMappingReportType>;
@@ -197,7 +1008,14 @@ export declare const FilesSyncReportType: StructType<{
     /** A dry run lists what a sync would take, and takes nothing */
     readonly dryRun: BooleanType;
     readonly mappings: ArrayType<StructType<{
-        readonly input: StringType;
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
         /** Files new since the last sync */
         readonly added: IntegerType;
         /** Files whose bytes changed */
@@ -206,25 +1024,201 @@ export declare const FilesSyncReportType: StructType<{
         readonly removed: IntegerType;
         /** Files as they were */
         readonly unchanged: IntegerType;
-        /** Files not taken: too large, or unreadable */
+        /** Files not taken, and why */
         readonly refused: ArrayType<StructType<{
             readonly key: StringType;
-            readonly reason: StringType;
+            readonly reason: VariantType<{
+                readonly too_large: StructType<{
+                    readonly size: IntegerType;
+                    readonly limit: IntegerType;
+                }>;
+                readonly segment_too_large: StructType<{
+                    readonly bytes: IntegerType;
+                    readonly limit: IntegerType;
+                }>;
+                readonly unreadable: StringType;
+                readonly not_beast2: StringType;
+                readonly type_mismatch: StructType<{
+                    readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                }>;
+                readonly mutation: StructType<{
+                    readonly outcome: StringType;
+                    readonly message: StringType;
+                }>;
+                readonly missing: StringType;
+                readonly other: StringType;
+            }>;
         }>>;
         /** The bytes taken in */
         readonly bytes: IntegerType;
-        /** Whether the input's value changed */
+        /** Whether the target's value changed */
         readonly updated: BooleanType;
+        /** The typed value taken in, for a typed mapping that took its file */
+        readonly taken: OptionType<StructType<{
+            /** The file's key */
+            readonly key: StringType;
+            /** The value's type: the mapping's */
+            readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            /** The collection's rows, where the store counts them */
+            readonly rows: OptionType<IntegerType>;
+            /** `carried` whole, or `split` into pieces by intake units */
+            readonly how: VariantType<{
+                readonly carried: NullType;
+                readonly split: NullType;
+            }>;
+        }>>;
+        /** The commit a seed or a feed made: `$init`, `$seed`, or the mutation's */
+        readonly commit: OptionType<StringType>;
+        /** Why a seed was not applied: the record has been mutated since its seed */
+        readonly kept: OptionType<StringType>;
+        /** Why a feed waits: its record has no state yet; tried again by the next sync */
+        readonly waiting: OptionType<StringType>;
     }>>;
 }>;
 export type FilesSyncReportType = typeof FilesSyncReportType;
 export type FilesSyncReport = ValueTypeOf<typeof FilesSyncReportType>;
+/** What a target took of one file. */
+export declare const FilesLedgerEntryType: StructType<{
+    readonly etag: StringType;
+    readonly size: IntegerType;
+    /** The file's SHA-256, where the sync hashed it (a typed file, a push) */
+    readonly sha256: OptionType<StringType>;
+    /** When the file was last written, as its listing said */
+    readonly modified: OptionType<DateTimeType>;
+}>;
+export type FilesLedgerEntryType = typeof FilesLedgerEntryType;
+export type FilesLedgerEntry = ValueTypeOf<typeof FilesLedgerEntryType>;
 /**
- * What an input took last: each file's ETag and size by its key, the value the
- * sync wrote (its hash), and what it was taken under: the mapping's shape and
- * where its source was bound, as one text. A sync trusts it only while the
- * input still holds that value and the mapping and binding are as they were,
- * so a ledger a sync wrote under other declarations, or from elsewhere, is
+ * What a target took last: each file's ETag, size and hash by its key, the
+ * value the sync wrote (its hash) or the commit it made, and what it was
+ * taken under: the mapping's shape and where its source was bound, as one
+ * text. A sync trusts it only while the target still holds that value (or
+ * that commit is its head) and the mapping and binding are as they were, so
+ * a ledger a sync wrote under other declarations, or from elsewhere, is
  * never read against these. The CLI keeps it in a local repository's state
  * file, the platform in its store.
  */
@@ -232,42 +1226,1798 @@ export declare const FilesLedgerType: StructType<{
     readonly entries: DictType<StringType, StructType<{
         readonly etag: StringType;
         readonly size: IntegerType;
+        /** The file's SHA-256, where the sync hashed it (a typed file, a push) */
+        readonly sha256: OptionType<StringType>;
+        /** When the file was last written, as its listing said */
+        readonly modified: OptionType<DateTimeType>;
     }>>;
+    /** The value the sync wrote, its hash: an input's */
     readonly value: OptionType<StringType>;
     readonly under: OptionType<StringType>;
+    /** The commit the sync made: a record's seed, a mutation's last feed */
+    readonly commit: OptionType<StringType>;
+    /** The SHA-256 of a feed the mutation refused: not tried again until the file changes */
+    readonly tried: OptionType<StringType>;
+    /**
+     * A typed intake under way across rounds: the file (its key and ETag, so
+     * another file is never resumed as it), its SHA-256 once its bytes are
+     * placed in the store (the delivery its intake resumes), else where its
+     * staging stood (the platform's own progress, as text)
+     */
+    readonly taking: OptionType<StructType<{
+        readonly key: StringType;
+        readonly etag: StringType;
+        readonly sha256: OptionType<StringType>;
+        readonly staging: OptionType<StringType>;
+    }>>;
 }>;
 export type FilesLedgerType = typeof FilesLedgerType;
 export type FilesLedgerValue = ValueTypeOf<typeof FilesLedgerType>;
-/** A workspace's Files: its declarations, its bindings and its last sync. */
+/** What a mapping holds, from its ledger: the file it took last. */
+export declare const FilesHeldType: StructType<{
+    readonly key: StringType;
+    readonly size: IntegerType;
+    readonly modified: OptionType<DateTimeType>;
+    readonly sha256: OptionType<StringType>;
+    /** The commit it made, for a record or a mutation */
+    readonly commit: OptionType<StringType>;
+}>;
+export type FilesHeldType = typeof FilesHeldType;
+export type FilesHeld = ValueTypeOf<typeof FilesHeldType>;
+/** A mapping's state: what it holds, and whether its record is pending. */
+export declare const FilesMappingStatusType: StructType<{
+    readonly target: VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>;
+    /** The file it holds; none before its first sync, or for a folder or listing */
+    readonly holds: OptionType<StructType<{
+        readonly key: StringType;
+        readonly size: IntegerType;
+        readonly modified: OptionType<DateTimeType>;
+        readonly sha256: OptionType<StringType>;
+        /** The commit it made, for a record or a mutation */
+        readonly commit: OptionType<StringType>;
+    }>>;
+    /** A record mapping whose record has no state yet: seeded by the next sync */
+    readonly pending: BooleanType;
+}>;
+export type FilesMappingStatusType = typeof FilesMappingStatusType;
+export type FilesMappingStatus = ValueTypeOf<typeof FilesMappingStatusType>;
+/** A workspace's Files: its declarations, its bindings, its last sync, and what each mapping holds. */
 export declare const FilesStatusType: StructType<{
     readonly manifest: OptionType<StructType<{
         /** The sources' names, in the order they were declared */
         readonly sources: ArrayType<StringType>;
         /** The mappings, in the order they were declared */
         readonly mappings: ArrayType<StructType<{
-            /** The input's name: the dataset `.inputs.<input>` */
-            readonly input: StringType;
+            /** What the files fill */
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
             /** The source's name */
             readonly source: StringType;
             readonly shape: VariantType<{
                 readonly file: StructType<{
                     readonly key: StringType;
+                    readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>>;
+                }>;
+                readonly latest: StructType<{
+                    readonly prefix: StringType;
+                    readonly include: OptionType<StringType>;
+                    readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>>;
+                }>;
+                readonly folder: StructType<{
+                    readonly prefix: StringType;
+                    readonly include: OptionType<StringType>;
+                }>;
+                readonly listing: StructType<{
+                    readonly prefix: StringType;
+                    readonly include: OptionType<StringType>;
+                }>;
+            }>;
+        }>>;
+    }>>;
+    readonly bindings: ArrayType<StructType<{
+        readonly source: StringType;
+        readonly url: StringType;
+        readonly region: OptionType<StringType>;
+        readonly profile: OptionType<StringType>;
+        readonly latest: OptionType<IntegerType>;
+    }>>;
+    readonly lastSync: OptionType<StructType<{
+        readonly started: DateTimeType;
+        readonly finished: DateTimeType;
+        /** A dry run lists what a sync would take, and takes nothing */
+        readonly dryRun: BooleanType;
+        readonly mappings: ArrayType<StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            /** Files new since the last sync */
+            readonly added: IntegerType;
+            /** Files whose bytes changed */
+            readonly changed: IntegerType;
+            /** Files gone from the source */
+            readonly removed: IntegerType;
+            /** Files as they were */
+            readonly unchanged: IntegerType;
+            /** Files not taken, and why */
+            readonly refused: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly reason: VariantType<{
+                    readonly too_large: StructType<{
+                        readonly size: IntegerType;
+                        readonly limit: IntegerType;
+                    }>;
+                    readonly segment_too_large: StructType<{
+                        readonly bytes: IntegerType;
+                        readonly limit: IntegerType;
+                    }>;
+                    readonly unreadable: StringType;
+                    readonly not_beast2: StringType;
+                    readonly type_mismatch: StructType<{
+                        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: NullType;
+                            readonly Null: NullType;
+                            readonly Boolean: NullType;
+                            readonly Integer: NullType;
+                            readonly Float: NullType;
+                            readonly String: NullType;
+                            readonly DateTime: NullType;
+                            readonly Blob: NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: NullType;
+                            readonly Null: NullType;
+                            readonly Boolean: NullType;
+                            readonly Integer: NullType;
+                            readonly Float: NullType;
+                            readonly String: NullType;
+                            readonly DateTime: NullType;
+                            readonly Blob: NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                    }>;
+                    readonly mutation: StructType<{
+                        readonly outcome: StringType;
+                        readonly message: StringType;
+                    }>;
+                    readonly missing: StringType;
+                    readonly other: StringType;
+                }>;
+            }>>;
+            /** The bytes taken in */
+            readonly bytes: IntegerType;
+            /** Whether the target's value changed */
+            readonly updated: BooleanType;
+            /** The typed value taken in, for a typed mapping that took its file */
+            readonly taken: OptionType<StructType<{
+                /** The file's key */
+                readonly key: StringType;
+                /** The value's type: the mapping's */
+                readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                /** The collection's rows, where the store counts them */
+                readonly rows: OptionType<IntegerType>;
+                /** `carried` whole, or `split` into pieces by intake units */
+                readonly how: VariantType<{
+                    readonly carried: NullType;
+                    readonly split: NullType;
+                }>;
+            }>>;
+            /** The commit a seed or a feed made: `$init`, `$seed`, or the mutation's */
+            readonly commit: OptionType<StringType>;
+            /** Why a seed was not applied: the record has been mutated since its seed */
+            readonly kept: OptionType<StringType>;
+            /** Why a feed waits: its record has no state yet; tried again by the next sync */
+            readonly waiting: OptionType<StringType>;
+        }>>;
+    }>>;
+    /** Each declared mapping's state, in the declarations' order; none without declarations */
+    readonly mappings: ArrayType<StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        /** The file it holds; none before its first sync, or for a folder or listing */
+        readonly holds: OptionType<StructType<{
+            readonly key: StringType;
+            readonly size: IntegerType;
+            readonly modified: OptionType<DateTimeType>;
+            readonly sha256: OptionType<StringType>;
+            /** The commit it made, for a record or a mutation */
+            readonly commit: OptionType<StringType>;
+        }>>;
+        /** A record mapping whose record has no state yet: seeded by the next sync */
+        readonly pending: BooleanType;
+    }>>;
+}>;
+export type FilesStatusType = typeof FilesStatusType;
+export type FilesStatus = ValueTypeOf<typeof FilesStatusType>;
+/**
+ * A bucket a deployment lets a repository's bindings point into, and the
+ * prefixes a binding's must begin with: in the deployment's own files bucket,
+ * the repository's folder (`{repo}/`); in a bucket its configuration lists
+ * (`files.sources`), the prefixes it grants the repository.
+ */
+export declare const FilesGrantType: StructType<{
+    readonly bucket: StringType;
+    readonly prefixes: ArrayType<StringType>;
+}>;
+export type FilesGrantType = typeof FilesGrantType;
+export type FilesGrant = ValueTypeOf<typeof FilesGrantType>;
+/** A package, as Files' responses name it. */
+export declare const FilesPackageType: StructType<{
+    readonly name: StringType;
+    readonly version: StringType;
+}>;
+export type FilesPackageType = typeof FilesPackageType;
+export type FilesPackage = ValueTypeOf<typeof FilesPackageType>;
+/** A deployed workspace's Files, as `GET …/files` answers them. */
+export declare const FilesWorkspaceType: StructType<{
+    /** Its declarations, its bindings, its last sync and what each mapping holds */
+    readonly status: StructType<{
+        readonly manifest: OptionType<StructType<{
+            /** The sources' names, in the order they were declared */
+            readonly sources: ArrayType<StringType>;
+            /** The mappings, in the order they were declared */
+            readonly mappings: ArrayType<StructType<{
+                /** What the files fill */
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
+                /** The source's name */
+                readonly source: StringType;
+                readonly shape: VariantType<{
+                    readonly file: StructType<{
+                        readonly key: StringType;
+                        readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: NullType;
+                            readonly Null: NullType;
+                            readonly Boolean: NullType;
+                            readonly Integer: NullType;
+                            readonly Float: NullType;
+                            readonly String: NullType;
+                            readonly DateTime: NullType;
+                            readonly Blob: NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>>;
+                    }>;
+                    readonly latest: StructType<{
+                        readonly prefix: StringType;
+                        readonly include: OptionType<StringType>;
+                        readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: NullType;
+                            readonly Null: NullType;
+                            readonly Boolean: NullType;
+                            readonly Integer: NullType;
+                            readonly Float: NullType;
+                            readonly String: NullType;
+                            readonly DateTime: NullType;
+                            readonly Blob: NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>>;
+                    }>;
+                    readonly folder: StructType<{
+                        readonly prefix: StringType;
+                        readonly include: OptionType<StringType>;
+                    }>;
+                    readonly listing: StructType<{
+                        readonly prefix: StringType;
+                        readonly include: OptionType<StringType>;
+                    }>;
+                }>;
+            }>>;
+        }>>;
+        readonly bindings: ArrayType<StructType<{
+            readonly source: StringType;
+            readonly url: StringType;
+            readonly region: OptionType<StringType>;
+            readonly profile: OptionType<StringType>;
+            readonly latest: OptionType<IntegerType>;
+        }>>;
+        readonly lastSync: OptionType<StructType<{
+            readonly started: DateTimeType;
+            readonly finished: DateTimeType;
+            /** A dry run lists what a sync would take, and takes nothing */
+            readonly dryRun: BooleanType;
+            readonly mappings: ArrayType<StructType<{
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
+                /** Files new since the last sync */
+                readonly added: IntegerType;
+                /** Files whose bytes changed */
+                readonly changed: IntegerType;
+                /** Files gone from the source */
+                readonly removed: IntegerType;
+                /** Files as they were */
+                readonly unchanged: IntegerType;
+                /** Files not taken, and why */
+                readonly refused: ArrayType<StructType<{
+                    readonly key: StringType;
+                    readonly reason: VariantType<{
+                        readonly too_large: StructType<{
+                            readonly size: IntegerType;
+                            readonly limit: IntegerType;
+                        }>;
+                        readonly segment_too_large: StructType<{
+                            readonly bytes: IntegerType;
+                            readonly limit: IntegerType;
+                        }>;
+                        readonly unreadable: StringType;
+                        readonly not_beast2: StringType;
+                        readonly type_mismatch: StructType<{
+                            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                                readonly Never: NullType;
+                                readonly Null: NullType;
+                                readonly Boolean: NullType;
+                                readonly Integer: NullType;
+                                readonly Float: NullType;
+                                readonly String: NullType;
+                                readonly DateTime: NullType;
+                                readonly Blob: NullType;
+                                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Dict: StructType<{
+                                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                                readonly Struct: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly Variant: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly Recursive: VariantType<{
+                                    readonly ref: IntegerType;
+                                    readonly wrapper: StructType<{
+                                        readonly id: IntegerType;
+                                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                }>;
+                                readonly Function: StructType<{
+                                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                                readonly AsyncFunction: StructType<{
+                                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                                readonly Never: NullType;
+                                readonly Null: NullType;
+                                readonly Boolean: NullType;
+                                readonly Integer: NullType;
+                                readonly Float: NullType;
+                                readonly String: NullType;
+                                readonly DateTime: NullType;
+                                readonly Blob: NullType;
+                                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Dict: StructType<{
+                                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                                readonly Struct: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly Variant: ArrayType<StructType<{
+                                    readonly name: StringType;
+                                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                                }>>;
+                                readonly Recursive: VariantType<{
+                                    readonly ref: IntegerType;
+                                    readonly wrapper: StructType<{
+                                        readonly id: IntegerType;
+                                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                    }>;
+                                }>;
+                                readonly Function: StructType<{
+                                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                                readonly AsyncFunction: StructType<{
+                                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                        }>;
+                        readonly mutation: StructType<{
+                            readonly outcome: StringType;
+                            readonly message: StringType;
+                        }>;
+                        readonly missing: StringType;
+                        readonly other: StringType;
+                    }>;
+                }>>;
+                /** The bytes taken in */
+                readonly bytes: IntegerType;
+                /** Whether the target's value changed */
+                readonly updated: BooleanType;
+                /** The typed value taken in, for a typed mapping that took its file */
+                readonly taken: OptionType<StructType<{
+                    /** The file's key */
+                    readonly key: StringType;
+                    /** The value's type: the mapping's */
+                    readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    /** The collection's rows, where the store counts them */
+                    readonly rows: OptionType<IntegerType>;
+                    /** `carried` whole, or `split` into pieces by intake units */
+                    readonly how: VariantType<{
+                        readonly carried: NullType;
+                        readonly split: NullType;
+                    }>;
+                }>>;
+                /** The commit a seed or a feed made: `$init`, `$seed`, or the mutation's */
+                readonly commit: OptionType<StringType>;
+                /** Why a seed was not applied: the record has been mutated since its seed */
+                readonly kept: OptionType<StringType>;
+                /** Why a feed waits: its record has no state yet; tried again by the next sync */
+                readonly waiting: OptionType<StringType>;
+            }>>;
+        }>>;
+        /** Each declared mapping's state, in the declarations' order; none without declarations */
+        readonly mappings: ArrayType<StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            /** The file it holds; none before its first sync, or for a folder or listing */
+            readonly holds: OptionType<StructType<{
+                readonly key: StringType;
+                readonly size: IntegerType;
+                readonly modified: OptionType<DateTimeType>;
+                readonly sha256: OptionType<StringType>;
+                /** The commit it made, for a record or a mutation */
+                readonly commit: OptionType<StringType>;
+            }>>;
+            /** A record mapping whose record has no state yet: seeded by the next sync */
+            readonly pending: BooleanType;
+        }>>;
+    }>;
+    /** Where the repository's bindings may point */
+    readonly granted: ArrayType<StructType<{
+        readonly bucket: StringType;
+        readonly prefixes: ArrayType<StringType>;
+    }>>;
+    /** The sync under way, its id, if any */
+    readonly syncing: OptionType<StringType>;
+}>;
+export type FilesWorkspaceType = typeof FilesWorkspaceType;
+export type FilesWorkspace = ValueTypeOf<typeof FilesWorkspaceType>;
+/**
+ * A deploy of declarations to a deployed workspace (`PUT …/files`). A
+ * protected workspace (one with a staging) takes its declarations only by a
+ * release from its staging: a deploy to it is refused `409
+ * workspace_protected`, unless an admin forces it, which its history records.
+ */
+export declare const FilesDeployRequestType: StructType<{
+    readonly manifest: StructType<{
+        /** The sources' names, in the order they were declared */
+        readonly sources: ArrayType<StringType>;
+        /** The mappings, in the order they were declared */
+        readonly mappings: ArrayType<StructType<{
+            /** What the files fill */
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            /** The source's name */
+            readonly source: StringType;
+            readonly shape: VariantType<{
+                readonly file: StructType<{
+                    readonly key: StringType;
+                    readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>>;
+                }>;
+                readonly latest: StructType<{
+                    readonly prefix: StringType;
+                    readonly include: OptionType<StringType>;
+                    readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>>;
+                }>;
+                readonly folder: StructType<{
+                    readonly prefix: StringType;
+                    readonly include: OptionType<StringType>;
+                }>;
+                readonly listing: StructType<{
+                    readonly prefix: StringType;
+                    readonly include: OptionType<StringType>;
+                }>;
+            }>;
+        }>>;
+    }>;
+    /** Check the declarations against the workspace's package, and keep nothing */
+    readonly dryRun: BooleanType;
+    /** Deploy past the workspace's protection: an admin's alone */
+    readonly force: BooleanType;
+}>;
+export type FilesDeployRequestType = typeof FilesDeployRequestType;
+export type FilesDeployRequest = ValueTypeOf<typeof FilesDeployRequestType>;
+/** A sync's request (`POST …/files/sync`). */
+export declare const FilesSyncRequestType: StructType<{
+    /** List what a sync would take, and take nothing */
+    readonly dryRun: BooleanType;
+    /** Only these targets; every declared target when none */
+    readonly targets: OptionType<ArrayType<VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>>>;
+    /** Records whose file is taken as their state again (`$seed`) whatever has mutated them since */
+    readonly reset: ArrayType<StringType>;
+}>;
+export type FilesSyncRequestType = typeof FilesSyncRequestType;
+export type FilesSyncRequest = ValueTypeOf<typeof FilesSyncRequestType>;
+/** What a sync's request did: started a sync, its id; or found one under way, its id, and started nothing. */
+export declare const FilesSyncStartType: VariantType<{
+    readonly started: StringType;
+    readonly running: StringType;
+}>;
+export type FilesSyncStartType = typeof FilesSyncStartType;
+export type FilesSyncStart = ValueTypeOf<typeof FilesSyncStartType>;
+/** Where a sync is: running, ended taking everything, or ended failing, and why. */
+export declare const FilesSyncStateType: VariantType<{
+    readonly running: NullType;
+    readonly succeeded: NullType;
+    readonly failed: StringType;
+}>;
+export type FilesSyncStateType = typeof FilesSyncStateType;
+export type FilesSyncState = ValueTypeOf<typeof FilesSyncStateType>;
+/**
+ * A deployed workspace's sync, run by the platform in rounds: who asked for
+ * it, what it was asked, where it is, and what it has taken, its rounds'
+ * together (`GET …/files/sync/:id`).
+ */
+export declare const FilesSyncJobType: StructType<{
+    readonly id: StringType;
+    readonly workspace: StringType;
+    /** Who asked for it: their email, else their subject */
+    readonly by: StringType;
+    readonly dryRun: BooleanType;
+    readonly targets: OptionType<ArrayType<VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>>>;
+    readonly reset: ArrayType<StringType>;
+    readonly state: VariantType<{
+        readonly running: NullType;
+        readonly succeeded: NullType;
+        readonly failed: StringType;
+    }>;
+    readonly startedAt: DateTimeType;
+    readonly finishedAt: OptionType<DateTimeType>;
+    /** What it has taken, per target; whole once it has ended */
+    readonly report: OptionType<StructType<{
+        readonly started: DateTimeType;
+        readonly finished: DateTimeType;
+        /** A dry run lists what a sync would take, and takes nothing */
+        readonly dryRun: BooleanType;
+        readonly mappings: ArrayType<StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            /** Files new since the last sync */
+            readonly added: IntegerType;
+            /** Files whose bytes changed */
+            readonly changed: IntegerType;
+            /** Files gone from the source */
+            readonly removed: IntegerType;
+            /** Files as they were */
+            readonly unchanged: IntegerType;
+            /** Files not taken, and why */
+            readonly refused: ArrayType<StructType<{
+                readonly key: StringType;
+                readonly reason: VariantType<{
+                    readonly too_large: StructType<{
+                        readonly size: IntegerType;
+                        readonly limit: IntegerType;
+                    }>;
+                    readonly segment_too_large: StructType<{
+                        readonly bytes: IntegerType;
+                        readonly limit: IntegerType;
+                    }>;
+                    readonly unreadable: StringType;
+                    readonly not_beast2: StringType;
+                    readonly type_mismatch: StructType<{
+                        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: NullType;
+                            readonly Null: NullType;
+                            readonly Boolean: NullType;
+                            readonly Integer: NullType;
+                            readonly Float: NullType;
+                            readonly String: NullType;
+                            readonly DateTime: NullType;
+                            readonly Blob: NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                            readonly Never: NullType;
+                            readonly Null: NullType;
+                            readonly Boolean: NullType;
+                            readonly Integer: NullType;
+                            readonly Float: NullType;
+                            readonly String: NullType;
+                            readonly DateTime: NullType;
+                            readonly Blob: NullType;
+                            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Dict: StructType<{
+                                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Struct: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Variant: ArrayType<StructType<{
+                                readonly name: StringType;
+                                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                            }>>;
+                            readonly Recursive: VariantType<{
+                                readonly ref: IntegerType;
+                                readonly wrapper: StructType<{
+                                    readonly id: IntegerType;
+                                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                                }>;
+                            }>;
+                            readonly Function: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly AsyncFunction: StructType<{
+                                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                    }>;
+                    readonly mutation: StructType<{
+                        readonly outcome: StringType;
+                        readonly message: StringType;
+                    }>;
+                    readonly missing: StringType;
+                    readonly other: StringType;
+                }>;
+            }>>;
+            /** The bytes taken in */
+            readonly bytes: IntegerType;
+            /** Whether the target's value changed */
+            readonly updated: BooleanType;
+            /** The typed value taken in, for a typed mapping that took its file */
+            readonly taken: OptionType<StructType<{
+                /** The file's key */
+                readonly key: StringType;
+                /** The value's type: the mapping's */
+                readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                /** The collection's rows, where the store counts them */
+                readonly rows: OptionType<IntegerType>;
+                /** `carried` whole, or `split` into pieces by intake units */
+                readonly how: VariantType<{
+                    readonly carried: NullType;
+                    readonly split: NullType;
+                }>;
+            }>>;
+            /** The commit a seed or a feed made: `$init`, `$seed`, or the mutation's */
+            readonly commit: OptionType<StringType>;
+            /** Why a seed was not applied: the record has been mutated since its seed */
+            readonly kept: OptionType<StringType>;
+            /** Why a feed waits: its record has no state yet; tried again by the next sync */
+            readonly waiting: OptionType<StringType>;
+        }>>;
+    }>>;
+}>;
+export type FilesSyncJobType = typeof FilesSyncJobType;
+export type FilesSyncJob = ValueTypeOf<typeof FilesSyncJobType>;
+/** A file a push offers: its name, where it came from, its size, its hash and its beast2 type. */
+export declare const FilesPushFileType: StructType<{
+    /** Its name: a file's own, or its path relative to the directory it came from */
+    readonly name: StringType;
+    /** The directory it came from, its own name, when a directory was pushed */
+    readonly directory: OptionType<StringType>;
+    readonly size: IntegerType;
+    /** Its SHA-256, hex */
+    readonly sha256: StringType;
+    /** The root type its beast2 header declares; none for a file that is no beast2 */
+    readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>>;
+}>;
+export type FilesPushFileType = typeof FilesPushFileType;
+export type FilesPushFile = ValueTypeOf<typeof FilesPushFileType>;
+/** A push's plan asked for (`POST …/files/push`): the files, and the target they are all for, if named. */
+export declare const FilesPushRequestType: StructType<{
+    readonly files: ArrayType<StructType<{
+        /** Its name: a file's own, or its path relative to the directory it came from */
+        readonly name: StringType;
+        /** The directory it came from, its own name, when a directory was pushed */
+        readonly directory: OptionType<StringType>;
+        readonly size: IntegerType;
+        /** Its SHA-256, hex */
+        readonly sha256: StringType;
+        /** The root type its beast2 header declares; none for a file that is no beast2 */
+        readonly type: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+    }>>;
+    /** The target every file is for ({@link filesTargetText}; a bare name when unique across kinds); none to match each by its name */
+    readonly as: OptionType<StringType>;
+}>;
+export type FilesPushRequestType = typeof FilesPushRequestType;
+export type FilesPushRequest = ValueTypeOf<typeof FilesPushRequestType>;
+/**
+ * How a planned file is put: one presigned PUT bound to its SHA-256; a
+ * multipart upload the platform created, a presigned URL per part,
+ * completed by `POST …/files/push/complete`; or `external`, a bucket the
+ * platform does not write, which the client puts with its own credentials.
+ */
+export declare const FilesPushUploadType: VariantType<{
+    readonly single: StructType<{
+        readonly url: StringType;
+        readonly headers: DictType<StringType, StringType>;
+    }>;
+    readonly multipart: StructType<{
+        readonly uploadId: StringType;
+        /** Each part's bytes but the last's */
+        readonly partBytes: IntegerType;
+        readonly parts: ArrayType<StructType<{
+            readonly number: IntegerType;
+            readonly url: StringType;
+        }>>;
+    }>;
+    readonly external: NullType;
+}>;
+export type FilesPushUploadType = typeof FilesPushUploadType;
+export type FilesPushUpload = ValueTypeOf<typeof FilesPushUploadType>;
+/**
+ * Why a push does not put a file.
+ *
+ * - `no_mapping`: no mapping takes a file of its name.
+ * - `ambiguous`: several would; name one with `as`.
+ * - `unknown_target`: `as` names no mapping.
+ * - `shape_mismatch`: a directory for a mapping that takes one file, or a
+ *   file for one that takes a folder (`directory`: which was offered).
+ * - `not_included`: a file the mapping's `include` glob leaves out, which
+ *   no sync would take.
+ * - `not_latest`: a `latest` mapping whose source holds a greater key.
+ * - `type_mismatch`, `not_beast2`, `too_large`: as a sync refuses them.
+ */
+export declare const FilesPushRefusalType: VariantType<{
+    readonly no_mapping: NullType;
+    readonly ambiguous: ArrayType<VariantType<{
+        readonly input: StringType;
+        readonly record: StringType;
+        readonly mutation: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+    }>>;
+    readonly unknown_target: StringType;
+    readonly shape_mismatch: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly directory: BooleanType;
+    }>;
+    readonly not_included: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly include: StringType;
+    }>;
+    readonly not_latest: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly greatest: StringType;
+    }>;
+    readonly type_mismatch: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    readonly not_beast2: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    readonly too_large: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly size: IntegerType;
+        readonly limit: IntegerType;
+    }>;
+}>;
+export type FilesPushRefusalType = typeof FilesPushRefusalType;
+export type FilesPushRefusal = ValueTypeOf<typeof FilesPushRefusalType>;
+/** What a push does with one file: puts it at a key, finds it there already, or refuses it. */
+export declare const FilesPushOutcomeType: VariantType<{
+    readonly put: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly source: StringType;
+        readonly key: StringType;
+        readonly upload: VariantType<{
+            readonly single: StructType<{
+                readonly url: StringType;
+                readonly headers: DictType<StringType, StringType>;
+            }>;
+            readonly multipart: StructType<{
+                readonly uploadId: StringType;
+                /** Each part's bytes but the last's */
+                readonly partBytes: IntegerType;
+                readonly parts: ArrayType<StructType<{
+                    readonly number: IntegerType;
+                    readonly url: StringType;
+                }>>;
+            }>;
+            readonly external: NullType;
+        }>;
+    }>;
+    readonly unchanged: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+        readonly source: StringType;
+        readonly key: StringType;
+    }>;
+    readonly refused: VariantType<{
+        readonly no_mapping: NullType;
+        readonly ambiguous: ArrayType<VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>>;
+        readonly unknown_target: StringType;
+        readonly shape_mismatch: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            readonly directory: BooleanType;
+        }>;
+        readonly not_included: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            readonly include: StringType;
+        }>;
+        readonly not_latest: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            readonly greatest: StringType;
+        }>;
+        readonly type_mismatch: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly not_beast2: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
                 }>;
-                readonly latest: StructType<{
-                    readonly prefix: StringType;
-                    readonly include: OptionType<StringType>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
                 }>;
-                readonly folder: StructType<{
-                    readonly prefix: StringType;
-                    readonly include: OptionType<StringType>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
                 }>;
-                readonly listing: StructType<{
-                    readonly prefix: StringType;
-                    readonly include: OptionType<StringType>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly too_large: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
                 }>;
             }>;
-        }>>;
-    }>>;
+            readonly size: IntegerType;
+            readonly limit: IntegerType;
+        }>;
+    }>;
+}>;
+export type FilesPushOutcomeType = typeof FilesPushOutcomeType;
+export type FilesPushOutcome = ValueTypeOf<typeof FilesPushOutcomeType>;
+/** A push's plan: each file's outcome, and the bindings the puts go to. */
+export declare const FilesPushPlanType: StructType<{
+    /** The bindings of the sources any file is put to */
     readonly bindings: ArrayType<StructType<{
         readonly source: StringType;
         readonly url: StringType;
@@ -275,251 +3025,287 @@ export declare const FilesStatusType: StructType<{
         readonly profile: OptionType<StringType>;
         readonly latest: OptionType<IntegerType>;
     }>>;
-    readonly lastSync: OptionType<StructType<{
-        readonly started: DateTimeType;
-        readonly finished: DateTimeType;
-        /** A dry run lists what a sync would take, and takes nothing */
-        readonly dryRun: BooleanType;
-        readonly mappings: ArrayType<StructType<{
-            readonly input: StringType;
-            /** Files new since the last sync */
-            readonly added: IntegerType;
-            /** Files whose bytes changed */
-            readonly changed: IntegerType;
-            /** Files gone from the source */
-            readonly removed: IntegerType;
-            /** Files as they were */
-            readonly unchanged: IntegerType;
-            /** Files not taken: too large, or unreadable */
-            readonly refused: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly reason: StringType;
-            }>>;
-            /** The bytes taken in */
-            readonly bytes: IntegerType;
-            /** Whether the input's value changed */
-            readonly updated: BooleanType;
-        }>>;
-    }>>;
-}>;
-export type FilesStatusType = typeof FilesStatusType;
-export type FilesStatus = ValueTypeOf<typeof FilesStatusType>;
-/**
- * A bucket a deployment lets a repository's bindings point into, and the
- * prefixes a binding's must begin with: in the deployment's own files bucket,
- * the repository's folder (`{repo}/`); in a bucket its configuration lists
- * (`files.sources`), the prefixes it grants the repository.
- */
-export declare const FilesGrantType: StructType<{
-    readonly bucket: StringType;
-    readonly prefixes: ArrayType<StringType>;
-}>;
-export type FilesGrantType = typeof FilesGrantType;
-export type FilesGrant = ValueTypeOf<typeof FilesGrantType>;
-/** A package, as Files' responses name it. */
-export declare const FilesPackageType: StructType<{
-    readonly name: StringType;
-    readonly version: StringType;
-}>;
-export type FilesPackageType = typeof FilesPackageType;
-export type FilesPackage = ValueTypeOf<typeof FilesPackageType>;
-/** A deployed workspace's Files, as `GET …/files` answers them. */
-export declare const FilesWorkspaceType: StructType<{
-    /** Its declarations, its bindings and its last sync */
-    readonly status: StructType<{
-        readonly manifest: OptionType<StructType<{
-            /** The sources' names, in the order they were declared */
-            readonly sources: ArrayType<StringType>;
-            /** The mappings, in the order they were declared */
-            readonly mappings: ArrayType<StructType<{
-                /** The input's name: the dataset `.inputs.<input>` */
-                readonly input: StringType;
-                /** The source's name */
-                readonly source: StringType;
-                readonly shape: VariantType<{
-                    readonly file: StructType<{
-                        readonly key: StringType;
-                    }>;
-                    readonly latest: StructType<{
-                        readonly prefix: StringType;
-                        readonly include: OptionType<StringType>;
+    readonly files: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly directory: OptionType<StringType>;
+        readonly outcome: VariantType<{
+            readonly put: StructType<{
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
                     }>;
-                    readonly folder: StructType<{
-                        readonly prefix: StringType;
-                        readonly include: OptionType<StringType>;
+                }>;
+                readonly source: StringType;
+                readonly key: StringType;
+                readonly upload: VariantType<{
+                    readonly single: StructType<{
+                        readonly url: StringType;
+                        readonly headers: DictType<StringType, StringType>;
                     }>;
-                    readonly listing: StructType<{
-                        readonly prefix: StringType;
-                        readonly include: OptionType<StringType>;
+                    readonly multipart: StructType<{
+                        readonly uploadId: StringType;
+                        /** Each part's bytes but the last's */
+                        readonly partBytes: IntegerType;
+                        readonly parts: ArrayType<StructType<{
+                            readonly number: IntegerType;
+                            readonly url: StringType;
+                        }>>;
                     }>;
-                }>;
-            }>>;
-        }>>;
-        readonly bindings: ArrayType<StructType<{
-            readonly source: StringType;
-            readonly url: StringType;
-            readonly region: OptionType<StringType>;
-            readonly profile: OptionType<StringType>;
-            readonly latest: OptionType<IntegerType>;
-        }>>;
-        readonly lastSync: OptionType<StructType<{
-            readonly started: DateTimeType;
-            readonly finished: DateTimeType;
-            /** A dry run lists what a sync would take, and takes nothing */
-            readonly dryRun: BooleanType;
-            readonly mappings: ArrayType<StructType<{
-                readonly input: StringType;
-                /** Files new since the last sync */
-                readonly added: IntegerType;
-                /** Files whose bytes changed */
-                readonly changed: IntegerType;
-                /** Files gone from the source */
-                readonly removed: IntegerType;
-                /** Files as they were */
-                readonly unchanged: IntegerType;
-                /** Files not taken: too large, or unreadable */
-                readonly refused: ArrayType<StructType<{
-                    readonly key: StringType;
-                    readonly reason: StringType;
-                }>>;
-                /** The bytes taken in */
-                readonly bytes: IntegerType;
-                /** Whether the input's value changed */
-                readonly updated: BooleanType;
-            }>>;
-        }>>;
-    }>;
-    /** Where the repository's bindings may point */
-    readonly granted: ArrayType<StructType<{
-        readonly bucket: StringType;
-        readonly prefixes: ArrayType<StringType>;
-    }>>;
-    /** The sync under way, its id, if any */
-    readonly syncing: OptionType<StringType>;
-}>;
-export type FilesWorkspaceType = typeof FilesWorkspaceType;
-export type FilesWorkspace = ValueTypeOf<typeof FilesWorkspaceType>;
-/**
- * A deploy of declarations to a deployed workspace (`PUT …/files`). A
- * protected workspace (one with a staging) takes its declarations only by a
- * release from its staging: a deploy to it is refused `409
- * workspace_protected`, unless an admin forces it, which its history records.
- */
-export declare const FilesDeployRequestType: StructType<{
-    readonly manifest: StructType<{
-        /** The sources' names, in the order they were declared */
-        readonly sources: ArrayType<StringType>;
-        /** The mappings, in the order they were declared */
-        readonly mappings: ArrayType<StructType<{
-            /** The input's name: the dataset `.inputs.<input>` */
-            readonly input: StringType;
-            /** The source's name */
-            readonly source: StringType;
-            readonly shape: VariantType<{
-                readonly file: StructType<{
-                    readonly key: StringType;
-                }>;
-                readonly latest: StructType<{
-                    readonly prefix: StringType;
-                    readonly include: OptionType<StringType>;
-                }>;
-                readonly folder: StructType<{
-                    readonly prefix: StringType;
-                    readonly include: OptionType<StringType>;
-                }>;
-                readonly listing: StructType<{
-                    readonly prefix: StringType;
-                    readonly include: OptionType<StringType>;
+                    readonly external: NullType;
                 }>;
             }>;
-        }>>;
-    }>;
-    /** Check the declarations against the workspace's package, and keep nothing */
-    readonly dryRun: BooleanType;
-    /** Deploy past the workspace's protection: an admin's alone */
-    readonly force: BooleanType;
-}>;
-export type FilesDeployRequestType = typeof FilesDeployRequestType;
-export type FilesDeployRequest = ValueTypeOf<typeof FilesDeployRequestType>;
-/** A sync's request (`POST …/files/sync`). */
-export declare const FilesSyncRequestType: StructType<{
-    /** List what a sync would take, and take nothing */
-    readonly dryRun: BooleanType;
-    /** Only these inputs; every declared input when none */
-    readonly inputs: OptionType<ArrayType<StringType>>;
-}>;
-export type FilesSyncRequestType = typeof FilesSyncRequestType;
-export type FilesSyncRequest = ValueTypeOf<typeof FilesSyncRequestType>;
-/** What a sync's request did: started a sync, its id; or found one under way, its id, and started nothing. */
-export declare const FilesSyncStartType: VariantType<{
-    readonly started: StringType;
-    readonly running: StringType;
-}>;
-export type FilesSyncStartType = typeof FilesSyncStartType;
-export type FilesSyncStart = ValueTypeOf<typeof FilesSyncStartType>;
-/** Where a sync is: running, ended taking everything, or ended failing, and why. */
-export declare const FilesSyncStateType: VariantType<{
-    readonly running: NullType;
-    readonly succeeded: NullType;
-    readonly failed: StringType;
-}>;
-export type FilesSyncStateType = typeof FilesSyncStateType;
-export type FilesSyncState = ValueTypeOf<typeof FilesSyncStateType>;
-/**
- * A deployed workspace's sync, run by the platform in rounds: who asked for
- * it, what it was asked, where it is, and what it has taken, its rounds'
- * together (`GET …/files/sync/:id`).
- */
-export declare const FilesSyncJobType: StructType<{
-    readonly id: StringType;
-    readonly workspace: StringType;
-    /** Who asked for it: their email, else their subject */
-    readonly by: StringType;
-    readonly dryRun: BooleanType;
-    readonly inputs: OptionType<ArrayType<StringType>>;
-    readonly state: VariantType<{
-        readonly running: NullType;
-        readonly succeeded: NullType;
-        readonly failed: StringType;
-    }>;
-    readonly startedAt: DateTimeType;
-    readonly finishedAt: OptionType<DateTimeType>;
-    /** What it has taken, per input; whole once it has ended */
-    readonly report: OptionType<StructType<{
-        readonly started: DateTimeType;
-        readonly finished: DateTimeType;
-        /** A dry run lists what a sync would take, and takes nothing */
-        readonly dryRun: BooleanType;
-        readonly mappings: ArrayType<StructType<{
-            readonly input: StringType;
-            /** Files new since the last sync */
-            readonly added: IntegerType;
-            /** Files whose bytes changed */
-            readonly changed: IntegerType;
-            /** Files gone from the source */
-            readonly removed: IntegerType;
-            /** Files as they were */
-            readonly unchanged: IntegerType;
-            /** Files not taken: too large, or unreadable */
-            readonly refused: ArrayType<StructType<{
+            readonly unchanged: StructType<{
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
+                readonly source: StringType;
                 readonly key: StringType;
-                readonly reason: StringType;
-            }>>;
-            /** The bytes taken in */
-            readonly bytes: IntegerType;
-            /** Whether the input's value changed */
-            readonly updated: BooleanType;
-        }>>;
+            }>;
+            readonly refused: VariantType<{
+                readonly no_mapping: NullType;
+                readonly ambiguous: ArrayType<VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>>;
+                readonly unknown_target: StringType;
+                readonly shape_mismatch: StructType<{
+                    readonly target: VariantType<{
+                        readonly input: StringType;
+                        readonly record: StringType;
+                        readonly mutation: StructType<{
+                            readonly record: StringType;
+                            readonly mutation: StringType;
+                        }>;
+                    }>;
+                    readonly directory: BooleanType;
+                }>;
+                readonly not_included: StructType<{
+                    readonly target: VariantType<{
+                        readonly input: StringType;
+                        readonly record: StringType;
+                        readonly mutation: StructType<{
+                            readonly record: StringType;
+                            readonly mutation: StringType;
+                        }>;
+                    }>;
+                    readonly include: StringType;
+                }>;
+                readonly not_latest: StructType<{
+                    readonly target: VariantType<{
+                        readonly input: StringType;
+                        readonly record: StringType;
+                        readonly mutation: StructType<{
+                            readonly record: StringType;
+                            readonly mutation: StringType;
+                        }>;
+                    }>;
+                    readonly greatest: StringType;
+                }>;
+                readonly type_mismatch: StructType<{
+                    readonly target: VariantType<{
+                        readonly input: StringType;
+                        readonly record: StringType;
+                        readonly mutation: StructType<{
+                            readonly record: StringType;
+                            readonly mutation: StringType;
+                        }>;
+                    }>;
+                    readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                }>;
+                readonly not_beast2: StructType<{
+                    readonly target: VariantType<{
+                        readonly input: StringType;
+                        readonly record: StringType;
+                        readonly mutation: StructType<{
+                            readonly record: StringType;
+                            readonly mutation: StringType;
+                        }>;
+                    }>;
+                    readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                        readonly Never: NullType;
+                        readonly Null: NullType;
+                        readonly Boolean: NullType;
+                        readonly Integer: NullType;
+                        readonly Float: NullType;
+                        readonly String: NullType;
+                        readonly DateTime: NullType;
+                        readonly Blob: NullType;
+                        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Dict: StructType<{
+                            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Struct: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Variant: ArrayType<StructType<{
+                            readonly name: StringType;
+                            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                        }>>;
+                        readonly Recursive: VariantType<{
+                            readonly ref: IntegerType;
+                            readonly wrapper: StructType<{
+                                readonly id: IntegerType;
+                                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                            }>;
+                        }>;
+                        readonly Function: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly AsyncFunction: StructType<{
+                            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                }>;
+                readonly too_large: StructType<{
+                    readonly target: VariantType<{
+                        readonly input: StringType;
+                        readonly record: StringType;
+                        readonly mutation: StructType<{
+                            readonly record: StringType;
+                            readonly mutation: StringType;
+                        }>;
+                    }>;
+                    readonly size: IntegerType;
+                    readonly limit: IntegerType;
+                }>;
+            }>;
+        }>;
     }>>;
 }>;
-export type FilesSyncJobType = typeof FilesSyncJobType;
-export type FilesSyncJob = ValueTypeOf<typeof FilesSyncJobType>;
+export type FilesPushPlanType = typeof FilesPushPlanType;
+export type FilesPushPlan = ValueTypeOf<typeof FilesPushPlanType>;
+/** The completion of a multipart upload a plan created (`POST …/files/push/complete`). */
+export declare const FilesPushCompleteRequestType: StructType<{
+    readonly key: StringType;
+    readonly uploadId: StringType;
+    readonly parts: ArrayType<StructType<{
+        readonly number: IntegerType;
+        readonly etag: StringType;
+    }>>;
+}>;
+export type FilesPushCompleteRequestType = typeof FilesPushCompleteRequestType;
+export type FilesPushCompleteRequest = ValueTypeOf<typeof FilesPushCompleteRequestType>;
+/** A completed upload: the object's ETag. */
+export declare const FilesPushCompleteResponseType: StructType<{
+    readonly etag: StringType;
+}>;
+export type FilesPushCompleteResponseType = typeof FilesPushCompleteResponseType;
+export type FilesPushCompleteResponse = ValueTypeOf<typeof FilesPushCompleteResponseType>;
 /**
  * Why declarations do not fit a package, or a binding does not fit them.
  *
- * - Against the package: `input_missing`, `input_not_writable`, `input_type`.
- * - The declarations themselves: `duplicate_input` (two mappings fill one
- *   input), `invalid_name` (a name e3 refuses), `invalid_key` (a key or
+ * - Against the package: `input_missing`, `input_not_writable`,
+ *   `input_type`; `record_missing`, `record_type`; `mutation_missing`,
+ *   `mutation_arity` (a fed mutation takes exactly one argument),
+ *   `mutation_patch` (a `patch` mutation takes a patch, not a value),
+ *   `mutation_type`.
+ * - The declarations themselves: `duplicate_target` (two mappings fill one
+ *   target), `target_shape` (a record or mutation mapped to a folder or a
+ *   listing), `target_untyped` (a record or mutation mapping naming no
+ *   type), `invalid_name` (a name e3 refuses), `invalid_key` (a key or
  *   prefix that is empty or not relative), `invalid_include` (a glob that
  *   matches nothing well-formed).
  * - Bindings: `source_unknown` (bound, but not declared), `source_unbound`
@@ -527,7 +3313,7 @@ export type FilesSyncJob = ValueTypeOf<typeof FilesSyncJobType>;
  *   `not_granted` (the deployment grants no source holding the URL), and
  *   `local_only` (`profile` or `latest`, on a deployed workspace).
  *
- * Types are compared exactly: `expected` is the shape's, `actual` the
+ * Types are compared exactly: `expected` is the mapping's, `actual` the
  * package's.
  *
  * @remarks
@@ -580,11 +3366,244 @@ export declare const FilesProblemType: VariantType<{
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
     }>;
-    readonly input_not_writable: StructType<{
-        readonly input: StringType;
+    readonly input_not_writable: StructType<{
+        readonly input: StringType;
+    }>;
+    readonly input_type: StructType<{
+        readonly input: StringType;
+        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    readonly record_missing: StructType<{
+        readonly record: StringType;
+        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    readonly record_type: StructType<{
+        readonly record: StringType;
+        readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+    }>;
+    readonly mutation_missing: StructType<{
+        readonly record: StringType;
+        readonly mutation: StringType;
     }>;
-    readonly input_type: StructType<{
-        readonly input: StringType;
+    readonly mutation_arity: StructType<{
+        readonly record: StringType;
+        readonly mutation: StringType;
+        readonly arity: IntegerType;
+    }>;
+    readonly mutation_patch: StructType<{
+        readonly record: StringType;
+        readonly mutation: StringType;
+    }>;
+    readonly mutation_type: StructType<{
+        readonly record: StringType;
+        readonly mutation: StringType;
         readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
             readonly Never: NullType;
             readonly Null: NullType;
@@ -670,8 +3689,35 @@ export declare const FilesProblemType: VariantType<{
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
     }>;
-    readonly duplicate_input: StructType<{
-        readonly input: StringType;
+    readonly duplicate_target: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+    }>;
+    readonly target_shape: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
+    }>;
+    readonly target_untyped: StructType<{
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
     }>;
     readonly invalid_name: StructType<{
         readonly kind: StringType;
@@ -679,12 +3725,26 @@ export declare const FilesProblemType: VariantType<{
         readonly reason: StringType;
     }>;
     readonly invalid_key: StructType<{
-        readonly input: StringType;
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
         readonly key: StringType;
         readonly reason: StringType;
     }>;
     readonly invalid_include: StructType<{
-        readonly input: StringType;
+        readonly target: VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>;
         readonly include: StringType;
         readonly reason: StringType;
     }>;
@@ -711,7 +3771,7 @@ export declare const FilesProblemType: VariantType<{
 export type FilesProblemType = typeof FilesProblemType;
 export type FilesProblem = ValueTypeOf<typeof FilesProblemType>;
 /**
- * What a deploy of declarations did: kept them, with the inputs whose
+ * What a deploy of declarations did: kept them, with the targets whose
  * declaration changed, which the next sync takes again whole; checked them
  * and kept nothing (a dry run); or refused them, naming every problem. Each
  * names the package the workspace runs, which they were checked against.
@@ -722,7 +3782,14 @@ export declare const FilesDeployResponseType: VariantType<{
             readonly name: StringType;
             readonly version: StringType;
         }>;
-        readonly retaken: ArrayType<StringType>;
+        readonly retaken: ArrayType<VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>>;
     }>;
     readonly checked: StructType<{
         readonly package: StructType<{
@@ -871,8 +3938,268 @@ export declare const FilesDeployResponseType: VariantType<{
                     readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
                 }>>;
             }>;
-            readonly duplicate_input: StructType<{
-                readonly input: StringType;
+            readonly record_missing: StructType<{
+                readonly record: StringType;
+                readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly record_type: StructType<{
+                readonly record: StringType;
+                readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly mutation_missing: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+            readonly mutation_arity: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+                readonly arity: IntegerType;
+            }>;
+            readonly mutation_patch: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+            readonly mutation_type: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+                readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                    readonly Never: NullType;
+                    readonly Null: NullType;
+                    readonly Boolean: NullType;
+                    readonly Integer: NullType;
+                    readonly Float: NullType;
+                    readonly String: NullType;
+                    readonly DateTime: NullType;
+                    readonly Blob: NullType;
+                    readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Dict: StructType<{
+                        readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                        readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Struct: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Variant: ArrayType<StructType<{
+                        readonly name: StringType;
+                        readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                    }>>;
+                    readonly Recursive: VariantType<{
+                        readonly ref: IntegerType;
+                        readonly wrapper: StructType<{
+                            readonly id: IntegerType;
+                            readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                        }>;
+                    }>;
+                    readonly Function: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly AsyncFunction: StructType<{
+                        readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                        readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                    readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>;
+            readonly duplicate_target: StructType<{
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
+            }>;
+            readonly target_shape: StructType<{
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
+            }>;
+            readonly target_untyped: StructType<{
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
             }>;
             readonly invalid_name: StructType<{
                 readonly kind: StringType;
@@ -880,12 +4207,26 @@ export declare const FilesDeployResponseType: VariantType<{
                 readonly reason: StringType;
             }>;
             readonly invalid_key: StructType<{
-                readonly input: StringType;
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
                 readonly key: StringType;
                 readonly reason: StringType;
             }>;
             readonly invalid_include: StructType<{
-                readonly input: StringType;
+                readonly target: VariantType<{
+                    readonly input: StringType;
+                    readonly record: StringType;
+                    readonly mutation: StructType<{
+                        readonly record: StringType;
+                        readonly mutation: StringType;
+                    }>;
+                }>;
                 readonly include: StringType;
                 readonly reason: StringType;
             }>;
@@ -914,12 +4255,19 @@ export declare const FilesDeployResponseType: VariantType<{
 export type FilesDeployResponseType = typeof FilesDeployResponseType;
 export type FilesDeployResponse = ValueTypeOf<typeof FilesDeployResponseType>;
 /**
- * What a bind did: kept the binding, with the inputs the next sync takes
+ * What a bind did: kept the binding, with the targets the next sync takes
  * again whole when it moved; or refused it, naming every problem.
  */
 export declare const FilesBindResponseType: VariantType<{
     readonly bound: StructType<{
-        readonly retaken: ArrayType<StringType>;
+        readonly retaken: ArrayType<VariantType<{
+            readonly input: StringType;
+            readonly record: StringType;
+            readonly mutation: StructType<{
+                readonly record: StringType;
+                readonly mutation: StringType;
+            }>;
+        }>>;
     }>;
     readonly refused: ArrayType<VariantType<{
         readonly input_missing: StructType<{
@@ -1057,8 +4405,268 @@ export declare const FilesBindResponseType: VariantType<{
                 readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
             }>>;
         }>;
-        readonly duplicate_input: StructType<{
-            readonly input: StringType;
+        readonly record_missing: StructType<{
+            readonly record: StringType;
+            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly record_type: StructType<{
+            readonly record: StringType;
+            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly mutation_missing: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+        readonly mutation_arity: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+            readonly arity: IntegerType;
+        }>;
+        readonly mutation_patch: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+        }>;
+        readonly mutation_type: StructType<{
+            readonly record: StringType;
+            readonly mutation: StringType;
+            readonly expected: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly actual: import("@elaraai/east").RecursiveType<VariantType<{
+                readonly Never: NullType;
+                readonly Null: NullType;
+                readonly Boolean: NullType;
+                readonly Integer: NullType;
+                readonly Float: NullType;
+                readonly String: NullType;
+                readonly DateTime: NullType;
+                readonly Blob: NullType;
+                readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Dict: StructType<{
+                    readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                    readonly value: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Struct: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Variant: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly type: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+                readonly Recursive: VariantType<{
+                    readonly ref: IntegerType;
+                    readonly wrapper: StructType<{
+                        readonly id: IntegerType;
+                        readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                    }>;
+                }>;
+                readonly Function: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly AsyncFunction: StructType<{
+                    readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                    readonly output: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+                readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+                readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>;
+        readonly duplicate_target: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+        }>;
+        readonly target_shape: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
+        }>;
+        readonly target_untyped: StructType<{
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
         }>;
         readonly invalid_name: StructType<{
             readonly kind: StringType;
@@ -1066,12 +4674,26 @@ export declare const FilesBindResponseType: VariantType<{
             readonly reason: StringType;
         }>;
         readonly invalid_key: StructType<{
-            readonly input: StringType;
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
             readonly key: StringType;
             readonly reason: StringType;
         }>;
         readonly invalid_include: StructType<{
-            readonly input: StringType;
+            readonly target: VariantType<{
+                readonly input: StringType;
+                readonly record: StringType;
+                readonly mutation: StructType<{
+                    readonly record: StringType;
+                    readonly mutation: StringType;
+                }>;
+            }>;
             readonly include: StringType;
             readonly reason: StringType;
         }>;
@@ -1098,6 +4720,20 @@ export declare const FilesBindResponseType: VariantType<{
 }>;
 export type FilesBindResponseType = typeof FilesBindResponseType;
 export type FilesBindResponse = ValueTypeOf<typeof FilesBindResponseType>;
+/**
+ * A type, briefly, as the problems and refusals print it.
+ *
+ * @param type - The type
+ * @returns Its summary, a few levels deep
+ */
+export declare function filesTypeWords(type: EastTypeValue): string;
+/**
+ * A refusal's reason as words that follow the file's key.
+ *
+ * @param reason - The reason
+ * @returns The words
+ */
+export declare function filesRefusalText(reason: FilesRefusalReason): string;
 /**
  * A problem as one line, which the CLI prints and an error's message carries.
  *
@@ -1105,4 +4741,11 @@ export type FilesBindResponse = ValueTypeOf<typeof FilesBindResponseType>;
  * @returns It, in a sentence
  */
 export declare function filesProblemText(problem: FilesProblem): string;
+/**
+ * A push's refusal as words that follow the file's name.
+ *
+ * @param refusal - The refusal
+ * @returns The words
+ */
+export declare function filesPushRefusalText(refusal: FilesPushRefusal): string;
 //# sourceMappingURL=files-types.d.ts.map