@elaraai/e3-cloud-types 1.0.91 → 1.0.93

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

@@ -0,0 +1,1108 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Licensed under BSL 1.1. See LICENSE for details.
+ */
+/**
+ * Files: a solution's inputs that come from files in a bucket, as East
+ * values.
+ *
+ * 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
+ * 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}.
+ *
+ * A file arrives as it is, a `Blob`: nothing here parses it.
+ */
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, 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).
+ */
+export declare const FILES_FILE_MAX_BYTES: number;
+/**
+ * The largest file a `folder` takes: beast2's largest segment, 64 MiB, less
+ * the room its path and lengths take (64 MiB less 64 KiB).
+ */
+export declare const FILES_FOLDER_ENTRY_MAX_BYTES: number;
+/** A file's row in a `listing` input. */
+export declare const FilesListingRowType: StructType<{
+    /** Its size in bytes */
+    readonly size: IntegerType;
+    /** When it was last written */
+    readonly modified: DateTimeType;
+    /** Its ETag: changes whenever its bytes do */
+    readonly etag: StringType;
+}>;
+export type FilesListingRowType = typeof FilesListingRowType;
+export type FilesListingRow = ValueTypeOf<typeof FilesListingRowType>;
+/** The input type of a `file` or `latest` mapping: 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>;
+/** The input type of a `listing` mapping: each file's path, relative to the prefix, to its row. */
+export declare const FilesListingType: DictType<StringType, StructType<{
+    /** Its size in bytes */
+    readonly size: IntegerType;
+    /** When it was last written */
+    readonly modified: DateTimeType;
+    /** Its ETag: changes whenever its bytes do */
+    readonly etag: StringType;
+}>>;
+/**
+ * What a mapping selects from its source, relative to where the workspace
+ * binds the source.
+ *
+ * - `file`: one key, as a `Blob`.
+ * - `latest`: the greatest key under a prefix that matches `include`, as a
+ *   `Blob`.
+ * - `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.
+ *
+ * `include` is a glob over the path relative to the prefix: `*` matches
+ * 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.
+ */
+export declare const FilesShapeType: 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>;
+    }>;
+}>;
+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>` */
+    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>;
+        }>;
+    }>;
+}>;
+export type FilesMappingType = typeof FilesMappingType;
+export type FilesMapping = ValueTypeOf<typeof FilesMappingType>;
+/** A solution's declarations: its sources, and the inputs 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;
+        /** 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>;
+            }>;
+        }>;
+    }>>;
+}>;
+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>;
+/** A file a sync did not take, and why. */
+export declare const FilesRefusalType: StructType<{
+    readonly key: StringType;
+    readonly reason: StringType;
+}>;
+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 */
+    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 FilesMappingReportType = typeof FilesMappingReportType;
+export type FilesMappingReport = ValueTypeOf<typeof FilesMappingReportType>;
+/** What one sync did. */
+export declare const FilesSyncReportType: 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 FilesSyncReportType = typeof FilesSyncReportType;
+export type FilesSyncReport = ValueTypeOf<typeof FilesSyncReportType>;
+/**
+ * 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
+ * never read against these. The CLI keeps it in a local repository's state
+ * file, the platform in its store.
+ */
+export declare const FilesLedgerType: StructType<{
+    readonly entries: DictType<StringType, StructType<{
+        readonly etag: StringType;
+        readonly size: IntegerType;
+    }>>;
+    readonly value: OptionType<StringType>;
+    readonly under: 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. */
+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;
+            /** 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 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;
+        }>>;
+    }>>;
+}>;
+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 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 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>;
+                }>;
+            }>;
+        }>>;
+    }>;
+    /** 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 key: StringType;
+                readonly reason: StringType;
+            }>>;
+            /** The bytes taken in */
+            readonly bytes: IntegerType;
+            /** Whether the input's value changed */
+            readonly updated: BooleanType;
+        }>>;
+    }>>;
+}>;
+export type FilesSyncJobType = typeof FilesSyncJobType;
+export type FilesSyncJob = ValueTypeOf<typeof FilesSyncJobType>;
+/**
+ * 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
+ *   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`
+ *   (declared, but not bound, when a sync needs it), `invalid_url`,
+ *   `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
+ * package's.
+ *
+ * @remarks
+ * WIRE COMPAT: a new case is a BEAST2 schema change, so the client and CLI
+ * ship with the server that emits it.
+ */
+export declare const FilesProblemType: VariantType<{
+    readonly input_missing: 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 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 duplicate_input: StructType<{
+        readonly input: StringType;
+    }>;
+    readonly invalid_name: StructType<{
+        readonly kind: StringType;
+        readonly name: StringType;
+        readonly reason: StringType;
+    }>;
+    readonly invalid_key: StructType<{
+        readonly input: StringType;
+        readonly key: StringType;
+        readonly reason: StringType;
+    }>;
+    readonly invalid_include: StructType<{
+        readonly input: StringType;
+        readonly include: StringType;
+        readonly reason: StringType;
+    }>;
+    readonly source_unknown: StructType<{
+        readonly source: StringType;
+    }>;
+    readonly source_unbound: StructType<{
+        readonly source: StringType;
+    }>;
+    readonly invalid_url: StructType<{
+        readonly source: StringType;
+        readonly url: StringType;
+        readonly reason: StringType;
+    }>;
+    readonly not_granted: StructType<{
+        readonly source: StringType;
+        readonly url: StringType;
+    }>;
+    readonly local_only: StructType<{
+        readonly source: StringType;
+        readonly option: StringType;
+    }>;
+}>;
+export type FilesProblemType = typeof FilesProblemType;
+export type FilesProblem = ValueTypeOf<typeof FilesProblemType>;
+/**
+ * What a deploy of declarations did: kept them, with the inputs 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.
+ */
+export declare const FilesDeployResponseType: VariantType<{
+    readonly deployed: StructType<{
+        readonly package: StructType<{
+            readonly name: StringType;
+            readonly version: StringType;
+        }>;
+        readonly retaken: ArrayType<StringType>;
+    }>;
+    readonly checked: StructType<{
+        readonly package: StructType<{
+            readonly name: StringType;
+            readonly version: StringType;
+        }>;
+    }>;
+    readonly refused: StructType<{
+        readonly package: StructType<{
+            readonly name: StringType;
+            readonly version: StringType;
+        }>;
+        readonly problems: ArrayType<VariantType<{
+            readonly input_missing: 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 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 duplicate_input: StructType<{
+                readonly input: StringType;
+            }>;
+            readonly invalid_name: StructType<{
+                readonly kind: StringType;
+                readonly name: StringType;
+                readonly reason: StringType;
+            }>;
+            readonly invalid_key: StructType<{
+                readonly input: StringType;
+                readonly key: StringType;
+                readonly reason: StringType;
+            }>;
+            readonly invalid_include: StructType<{
+                readonly input: StringType;
+                readonly include: StringType;
+                readonly reason: StringType;
+            }>;
+            readonly source_unknown: StructType<{
+                readonly source: StringType;
+            }>;
+            readonly source_unbound: StructType<{
+                readonly source: StringType;
+            }>;
+            readonly invalid_url: StructType<{
+                readonly source: StringType;
+                readonly url: StringType;
+                readonly reason: StringType;
+            }>;
+            readonly not_granted: StructType<{
+                readonly source: StringType;
+                readonly url: StringType;
+            }>;
+            readonly local_only: StructType<{
+                readonly source: StringType;
+                readonly option: StringType;
+            }>;
+        }>>;
+    }>;
+}>;
+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
+ * again whole when it moved; or refused it, naming every problem.
+ */
+export declare const FilesBindResponseType: VariantType<{
+    readonly bound: StructType<{
+        readonly retaken: ArrayType<StringType>;
+    }>;
+    readonly refused: ArrayType<VariantType<{
+        readonly input_missing: 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 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 duplicate_input: StructType<{
+            readonly input: StringType;
+        }>;
+        readonly invalid_name: StructType<{
+            readonly kind: StringType;
+            readonly name: StringType;
+            readonly reason: StringType;
+        }>;
+        readonly invalid_key: StructType<{
+            readonly input: StringType;
+            readonly key: StringType;
+            readonly reason: StringType;
+        }>;
+        readonly invalid_include: StructType<{
+            readonly input: StringType;
+            readonly include: StringType;
+            readonly reason: StringType;
+        }>;
+        readonly source_unknown: StructType<{
+            readonly source: StringType;
+        }>;
+        readonly source_unbound: StructType<{
+            readonly source: StringType;
+        }>;
+        readonly invalid_url: StructType<{
+            readonly source: StringType;
+            readonly url: StringType;
+            readonly reason: StringType;
+        }>;
+        readonly not_granted: StructType<{
+            readonly source: StringType;
+            readonly url: StringType;
+        }>;
+        readonly local_only: StructType<{
+            readonly source: StringType;
+            readonly option: StringType;
+        }>;
+    }>>;
+}>;
+export type FilesBindResponseType = typeof FilesBindResponseType;
+export type FilesBindResponse = ValueTypeOf<typeof FilesBindResponseType>;
+/**
+ * A problem as one line, which the CLI prints and an error's message carries.
+ *
+ * @param problem - The problem
+ * @returns It, in a sentence
+ */
+export declare function filesProblemText(problem: FilesProblem): string;
+//# sourceMappingURL=files-types.d.ts.map