@org-quicko/silo-client 1.0.0

package/dist/silo.d.ts

@@ -0,0 +1,42 @@
+import type { HealthReport } from "./instance/health-report.js";
+import { Media } from "./media/media.js";
+import type { RequestOptions } from "./request-options.js";
+import { ProjectHandle } from "./scope/project-handle.js";
+import { Projects } from "./scope/projects.js";
+import type { EnvironmentHandle } from "./scope/environment-handle.js";
+import type { SearchPage } from "./search/search-page.js";
+import type { SearchQuery } from "./search/search-query.js";
+import type { SiloOptions } from "./silo-options.js";
+/**
+ * One silo instance. Navigate it the way the API is shaped:
+ * `silo.project("acme").environment("prod").collection<Post>("posts")`.
+ *
+ * Handles are value objects and make no request, so nothing in a chain needs
+ * an `await` until the call at the end. There is deliberately no default
+ * project or environment: both names are always given.
+ */
+export declare class Silo {
+    /** The projects this key can see, and creating one. */
+    readonly projects: Projects;
+    /** The media catalog. Media is instance-global, so it takes no scope. */
+    readonly media: Media;
+    private readonly options;
+    private readonly transport;
+    constructor(options: SiloOptions);
+    /** One project, by the name every path addresses it with. */
+    project(name: string): ProjectHandle;
+    /** `silo.project(p).environment(e)` in one call. Still takes both names. */
+    scope(project: string, environment: string): EnvironmentHandle;
+    /**
+     * Search everything this key can read. The narrower reaches are
+     * `environment.search()` and `collection.search()`, so a reach is always
+     * the receiver and never an argument that could be forgotten.
+     */
+    search(query: SearchQuery, options?: RequestOptions): Promise<SearchPage>;
+    /** Liveness and version. The one route that is never authenticated. */
+    health(options?: RequestOptions): Promise<HealthReport>;
+    /** The same instance read with a different key. */
+    withKey(key: string | undefined): Silo;
+    /** The same options pointed at a different server. */
+    withUrl(url: string): Silo;
+}

package/dist/transport/abort-signals.d.cts

@@ -0,0 +1,23 @@
+/** Which source aborted the composed signal, so the caller can raise
+ * `TimeoutError` or `RequestAbortedError` instead of one undifferentiated
+ * abort. */
+export type AbortReason = "caller" | "timeout";
+/**
+ * Composes a caller's `AbortSignal` with a timeout deadline into one signal,
+ * and remembers which of the two fired first.
+ *
+ * Built by hand with an `AbortController` and listeners rather than
+ * `AbortSignal.any`, which Node 18 does not have. Call {@link dispose} once
+ * the request settles, whichever way, so the timer clears and neither
+ * listener outlives the request.
+ */
+export declare class AbortSignals {
+    readonly signal: AbortSignal;
+    private reason;
+    private readonly cleanups;
+    constructor(callerSignal: AbortSignal | undefined, timeoutMilliseconds: number | undefined);
+    /** Which source fired, or `undefined` if the signal never aborted. */
+    firedBy(): AbortReason | undefined;
+    /** Removes the listeners and clears the timer. Idempotent. */
+    dispose(): void;
+}

package/dist/transport/abort-signals.d.ts

@@ -0,0 +1,23 @@
+/** Which source aborted the composed signal, so the caller can raise
+ * `TimeoutError` or `RequestAbortedError` instead of one undifferentiated
+ * abort. */
+export type AbortReason = "caller" | "timeout";
+/**
+ * Composes a caller's `AbortSignal` with a timeout deadline into one signal,
+ * and remembers which of the two fired first.
+ *
+ * Built by hand with an `AbortController` and listeners rather than
+ * `AbortSignal.any`, which Node 18 does not have. Call {@link dispose} once
+ * the request settles, whichever way, so the timer clears and neither
+ * listener outlives the request.
+ */
+export declare class AbortSignals {
+    readonly signal: AbortSignal;
+    private reason;
+    private readonly cleanups;
+    constructor(callerSignal: AbortSignal | undefined, timeoutMilliseconds: number | undefined);
+    /** Which source fired, or `undefined` if the signal never aborted. */
+    firedBy(): AbortReason | undefined;
+    /** Removes the listeners and clears the timer. Idempotent. */
+    dispose(): void;
+}

package/dist/transport/api-path.d.cts

@@ -0,0 +1,36 @@
+/**
+ * Every path in the client, built in one place. Every dynamic segment goes
+ * through `encodeURIComponent`, so a name containing a slash or a space
+ * addresses one resource rather than being split across the path.
+ *
+ * Uses `/envs/`, not `/environments/` — the guide says both are accepted
+ *, and one spelling is enough to build with.
+ */
+export declare class ApiPath {
+    static health(): string;
+    static projects(): string;
+    static project(project: string): string;
+    static environments(project: string): string;
+    static environment(project: string, env: string): string;
+    static projectVariables(project: string): string;
+    static projectVariable(project: string, name: string): string;
+    static environmentVariables(project: string, env: string): string;
+    static environmentVariable(project: string, env: string, name: string): string;
+    static collections(project: string, env: string): string;
+    static collection(project: string, env: string, name: string): string;
+    static schemas(project: string, env: string): string;
+    static collectionSchema(project: string, env: string, name: string): string;
+    /** List/create entries: the same address as `collection`, one level down
+     * in what it means — the collection's own record versus its rows. */
+    static entries(project: string, env: string, name: string): string;
+    static entry(project: string, env: string, name: string, id: string): string;
+    static collectionSearch(project: string, env: string, name: string): string;
+    static environmentSearch(project: string, env: string): string;
+    static instanceSearch(): string;
+    static media(): string;
+    static mediaExtensions(): string;
+    static mediaAsset(id: string): string;
+    static mediaAssetUsages(id: string): string;
+    static mediaBulkDelete(): string;
+    static mediaFolders(): string;
+}

package/dist/transport/api-path.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Every path in the client, built in one place. Every dynamic segment goes
+ * through `encodeURIComponent`, so a name containing a slash or a space
+ * addresses one resource rather than being split across the path.
+ *
+ * Uses `/envs/`, not `/environments/` — the guide says both are accepted
+ *, and one spelling is enough to build with.
+ */
+export declare class ApiPath {
+    static health(): string;
+    static projects(): string;
+    static project(project: string): string;
+    static environments(project: string): string;
+    static environment(project: string, env: string): string;
+    static projectVariables(project: string): string;
+    static projectVariable(project: string, name: string): string;
+    static environmentVariables(project: string, env: string): string;
+    static environmentVariable(project: string, env: string, name: string): string;
+    static collections(project: string, env: string): string;
+    static collection(project: string, env: string, name: string): string;
+    static schemas(project: string, env: string): string;
+    static collectionSchema(project: string, env: string, name: string): string;
+    /** List/create entries: the same address as `collection`, one level down
+     * in what it means — the collection's own record versus its rows. */
+    static entries(project: string, env: string, name: string): string;
+    static entry(project: string, env: string, name: string, id: string): string;
+    static collectionSearch(project: string, env: string, name: string): string;
+    static environmentSearch(project: string, env: string): string;
+    static instanceSearch(): string;
+    static media(): string;
+    static mediaExtensions(): string;
+    static mediaAsset(id: string): string;
+    static mediaAssetUsages(id: string): string;
+    static mediaBulkDelete(): string;
+    static mediaFolders(): string;
+}

package/dist/transport/fetch-function.d.cts

@@ -0,0 +1,11 @@
+/**
+ * The shape `Transport` calls to make a request: fetch's call signature, so
+ * any drop-in replacement (a test double, a patched runtime fetch) can
+ * stand in for it via `SiloOptions.fetch`.
+ *
+ * A plain function type rather than `typeof fetch`, deliberately: the
+ * ambient global `fetch` can carry extra static properties in some runtimes
+ * (Bun's `fetch.preconnect`, for one), and this type should demand only the
+ * call signature a replacement actually needs.
+ */
+export type FetchFunction = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/transport/fetch-function.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The shape `Transport` calls to make a request: fetch's call signature, so
+ * any drop-in replacement (a test double, a patched runtime fetch) can
+ * stand in for it via `SiloOptions.fetch`.
+ *
+ * A plain function type rather than `typeof fetch`, deliberately: the
+ * ambient global `fetch` can carry extra static properties in some runtimes
+ * (Bun's `fetch.preconnect`, for one), and this type should demand only the
+ * call signature a replacement actually needs.
+ */
+export type FetchFunction = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;

package/dist/transport/page-payload.d.cts

@@ -0,0 +1,15 @@
+/** What {@link PagePayload.read} extracts from a list response body. */
+export interface PagePayloadRows<Row> {
+    rows: Row[];
+    total: number;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Reads a list response body. The wire uses `data` for entries and search
+ * and `items` for media, collections and projects — this is the only
+ * place in the client that knows both names.
+ */
+export declare class PagePayload {
+    static read<Row>(body: Record<string, unknown>): PagePayloadRows<Row>;
+}

package/dist/transport/page-payload.d.ts

@@ -0,0 +1,15 @@
+/** What {@link PagePayload.read} extracts from a list response body. */
+export interface PagePayloadRows<Row> {
+    rows: Row[];
+    total: number;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Reads a list response body. The wire uses `data` for entries and search
+ * and `items` for media, collections and projects — this is the only
+ * place in the client that knows both names.
+ */
+export declare class PagePayload {
+    static read<Row>(body: Record<string, unknown>): PagePayloadRows<Row>;
+}

package/dist/transport/query-string.d.cts

@@ -0,0 +1,10 @@
+import type { TransportQueryValue } from "./transport-request.cjs";
+/**
+ * Builds the `?a=1&b=2` suffix for a request. Omits `undefined` and `null`
+ * values, JSON-encodes an object value (the `filter` AST) before
+ * URL-encoding it, and returns `""` when nothing is set — so a call site can
+ * concatenate the result onto a path unconditionally.
+ */
+export declare class QueryString {
+    static build(query: Record<string, TransportQueryValue> | undefined): string;
+}

package/dist/transport/query-string.d.ts

@@ -0,0 +1,10 @@
+import type { TransportQueryValue } from "./transport-request.js";
+/**
+ * Builds the `?a=1&b=2` suffix for a request. Omits `undefined` and `null`
+ * values, JSON-encodes an object value (the `filter` AST) before
+ * URL-encoding it, and returns `""` when nothing is set — so a call site can
+ * concatenate the result onto a path unconditionally.
+ */
+export declare class QueryString {
+    static build(query: Record<string, TransportQueryValue> | undefined): string;
+}

package/dist/transport/response-decoder.d.cts

@@ -0,0 +1,14 @@
+/**
+ * Decodes a successful response by its content type: `204` to `undefined`,
+ * `application/json` to parsed JSON, everything else to text.
+ *
+ * `expectJson` is true for a route documented to answer JSON — a body of any
+ * other content type there raises `InvalidResponseError` rather than being
+ * handed back as text nobody asked for.
+ */
+export declare class ResponseDecoder {
+    static decode(response: Response, request: {
+        method: string;
+        path: string;
+    }, expectJson: boolean): Promise<unknown>;
+}

package/dist/transport/response-decoder.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Decodes a successful response by its content type: `204` to `undefined`,
+ * `application/json` to parsed JSON, everything else to text.
+ *
+ * `expectJson` is true for a route documented to answer JSON — a body of any
+ * other content type there raises `InvalidResponseError` rather than being
+ * handed back as text nobody asked for.
+ */
+export declare class ResponseDecoder {
+    static decode(response: Response, request: {
+        method: string;
+        path: string;
+    }, expectJson: boolean): Promise<unknown>;
+}

package/dist/transport/route-inventory.d.cts

@@ -0,0 +1,22 @@
+/**
+ * Every route this client reaches, and every route it deliberately does not.
+ *
+ * The point is that the two lists together must account for the whole API: a
+ * route in neither is a gap, and `test/contract/route-inventory.test.ts`
+ * checks them against the server's own registrations rather than against
+ * `docs/guide/http-api.md`, which can be, and has been, incomplete.
+ *
+ * Paths use the server's own `:param` spelling and the `/envs/` spelling of
+ * the two it accepts.
+ */
+export declare class RouteInventory {
+    /** Reached by a typed method on the client. */
+    static readonly Covered: readonly string[];
+    /**
+     * Out of scope on purpose, each with the reason. Operator surfaces belong
+     * to the admin UI and the CLI; none of them is content.
+     */
+    static readonly OutOfScope: Readonly<Record<string, string>>;
+    /** Whether the inventory accounts for a route at all. */
+    static accountsFor(route: string): boolean;
+}

package/dist/transport/route-inventory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Every route this client reaches, and every route it deliberately does not.
+ *
+ * The point is that the two lists together must account for the whole API: a
+ * route in neither is a gap, and `test/contract/route-inventory.test.ts`
+ * checks them against the server's own registrations rather than against
+ * `docs/guide/http-api.md`, which can be, and has been, incomplete.
+ *
+ * Paths use the server's own `:param` spelling and the `/envs/` spelling of
+ * the two it accepts.
+ */
+export declare class RouteInventory {
+    /** Reached by a typed method on the client. */
+    static readonly Covered: readonly string[];
+    /**
+     * Out of scope on purpose, each with the reason. Operator surfaces belong
+     * to the admin UI and the CLI; none of them is content.
+     */
+    static readonly OutOfScope: Readonly<Record<string, string>>;
+    /** Whether the inventory accounts for a route at all. */
+    static accountsFor(route: string): boolean;
+}

package/dist/transport/transport-request.d.cts

@@ -0,0 +1,18 @@
+/** One query parameter's value. An object (the `filter` AST) is JSON-encoded
+ *  by {@link QueryString}; everything else is stringified. */
+export type TransportQueryValue = string | number | boolean | object | undefined;
+/**
+ * One request through {@link Transport}: an HTTP method and a path already
+ * built by {@link ApiPath}, with everything else optional. `signal` and
+ * `timeoutMilliseconds` here are the per-call values from {@link RequestOptions};
+ * the client's own defaults apply when they are absent.
+ */
+export interface TransportRequest {
+    method: string;
+    path: string;
+    query?: Record<string, TransportQueryValue>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    timeoutMilliseconds?: number;
+}

package/dist/transport/transport-request.d.ts

@@ -0,0 +1,18 @@
+/** One query parameter's value. An object (the `filter` AST) is JSON-encoded
+ *  by {@link QueryString}; everything else is stringified. */
+export type TransportQueryValue = string | number | boolean | object | undefined;
+/**
+ * One request through {@link Transport}: an HTTP method and a path already
+ * built by {@link ApiPath}, with everything else optional. `signal` and
+ * `timeoutMilliseconds` here are the per-call values from {@link RequestOptions};
+ * the client's own defaults apply when they are absent.
+ */
+export interface TransportRequest {
+    method: string;
+    path: string;
+    query?: Record<string, TransportQueryValue>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    timeoutMilliseconds?: number;
+}

package/dist/transport/transport.d.cts

@@ -0,0 +1,45 @@
+import type { FetchFunction } from "./fetch-function.cjs";
+import type { TransportRequest } from "./transport-request.cjs";
+/** What `Transport` needs to construct — its own options shape. */
+export interface TransportOptions {
+    url: string;
+    key?: string;
+    headers?: Record<string, string>;
+    timeoutMilliseconds?: number;
+    fetch?: FetchFunction;
+}
+/**
+ * The one place a request is made. Sends `Authorization: Bearer <key>`
+ * when a key is set and nothing when it is not, since anonymous reads are
+ * legal. A `fetch` rejection becomes `NetworkError`; an abort from the
+ * caller's own signal becomes `RequestAbortedError`; an abort from the
+ * deadline becomes `TimeoutError` — `AbortSignals` is what tells the three
+ * apart.
+ */
+export declare class Transport {
+    private readonly url;
+    private readonly key;
+    private readonly headers;
+    private readonly timeoutMilliseconds;
+    private readonly fetchFunction;
+    constructor(options: TransportOptions);
+    json<T>(request: TransportRequest): Promise<T>;
+    /** For a `204` response: decodes it, and discards the result. */
+    empty(request: TransportRequest): Promise<void>;
+    stream(request: TransportRequest): Promise<ReadableStream<Uint8Array> | null>;
+    /** Multipart upload. Never sets `Content-Type` by hand — the runtime sets
+     * it, boundary included, from the `FormData` body. */
+    upload<T>(request: TransportRequest, form: FormData): Promise<T>;
+    /** A new `Transport` reading a different key, sharing everything else. */
+    withKey(key: string | undefined): Transport;
+    /** A new `Transport` reading a different base URL, sharing everything
+     * else. */
+    withUrl(url: string): Transport;
+    private snapshot;
+    private execute;
+    /** Distinguishes why `fetch` itself failed: the deadline, the caller's own
+     * signal, or the request never landing at all. */
+    private transportFailure;
+    private buildHeaders;
+    private static normalizeUrl;
+}

package/dist/transport/transport.d.ts

@@ -0,0 +1,45 @@
+import type { FetchFunction } from "./fetch-function.js";
+import type { TransportRequest } from "./transport-request.js";
+/** What `Transport` needs to construct — its own options shape. */
+export interface TransportOptions {
+    url: string;
+    key?: string;
+    headers?: Record<string, string>;
+    timeoutMilliseconds?: number;
+    fetch?: FetchFunction;
+}
+/**
+ * The one place a request is made. Sends `Authorization: Bearer <key>`
+ * when a key is set and nothing when it is not, since anonymous reads are
+ * legal. A `fetch` rejection becomes `NetworkError`; an abort from the
+ * caller's own signal becomes `RequestAbortedError`; an abort from the
+ * deadline becomes `TimeoutError` — `AbortSignals` is what tells the three
+ * apart.
+ */
+export declare class Transport {
+    private readonly url;
+    private readonly key;
+    private readonly headers;
+    private readonly timeoutMilliseconds;
+    private readonly fetchFunction;
+    constructor(options: TransportOptions);
+    json<T>(request: TransportRequest): Promise<T>;
+    /** For a `204` response: decodes it, and discards the result. */
+    empty(request: TransportRequest): Promise<void>;
+    stream(request: TransportRequest): Promise<ReadableStream<Uint8Array> | null>;
+    /** Multipart upload. Never sets `Content-Type` by hand — the runtime sets
+     * it, boundary included, from the `FormData` body. */
+    upload<T>(request: TransportRequest, form: FormData): Promise<T>;
+    /** A new `Transport` reading a different key, sharing everything else. */
+    withKey(key: string | undefined): Transport;
+    /** A new `Transport` reading a different base URL, sharing everything
+     * else. */
+    withUrl(url: string): Transport;
+    private snapshot;
+    private execute;
+    /** Distinguishes why `fetch` itself failed: the deadline, the caller's own
+     * signal, or the request never landing at all. */
+    private transportFailure;
+    private buildHeaders;
+    private static normalizeUrl;
+}

package/dist/variables/environment-variables.d.cts

@@ -0,0 +1,14 @@
+import type { RequestOptions } from "../request-options.cjs";
+import type { ScopeReference } from "../scope/scope-reference.cjs";
+import { Variable } from "./variable.cjs";
+/** This environment's values: `list`, `set`, `unset`. Declaring, renaming
+ *  and undeclaring a name are project-wide and live on `ProjectVariables`. */
+export declare class EnvironmentVariables {
+    private readonly scope;
+    constructor(scope: ScopeReference);
+    list(options?: RequestOptions): Promise<Variable[]>;
+    set(name: string, value: string, options?: RequestOptions): Promise<Variable>;
+    /** Clears this environment's value, leaving the name declared — the server
+     *  answers the updated declaration rather than `204`. */
+    unset(name: string, options?: RequestOptions): Promise<Variable>;
+}

package/dist/variables/environment-variables.d.ts

@@ -0,0 +1,14 @@
+import type { RequestOptions } from "../request-options.js";
+import type { ScopeReference } from "../scope/scope-reference.js";
+import { Variable } from "./variable.js";
+/** This environment's values: `list`, `set`, `unset`. Declaring, renaming
+ *  and undeclaring a name are project-wide and live on `ProjectVariables`. */
+export declare class EnvironmentVariables {
+    private readonly scope;
+    constructor(scope: ScopeReference);
+    list(options?: RequestOptions): Promise<Variable[]>;
+    set(name: string, value: string, options?: RequestOptions): Promise<Variable>;
+    /** Clears this environment's value, leaving the name declared — the server
+     *  answers the updated declaration rather than `204`. */
+    unset(name: string, options?: RequestOptions): Promise<Variable>;
+}

package/dist/variables/project-variables.d.cts

@@ -0,0 +1,38 @@
+import type { RequestOptions } from "../request-options.cjs";
+import type { Transport } from "../transport/transport.cjs";
+import { Variable } from "./variable.cjs";
+/** `declare()`'s options: `environment` is where the initial `value` lands,
+ *  when one is given at all. */
+export interface DeclareVariableOptions extends RequestOptions {
+    description?: string;
+    environment?: string;
+    value?: string;
+}
+/**
+ * `rename()`/`describe()`/`undeclare()`'s options. `environment` is not
+ * load-bearing for what these three do — declaring, renaming and
+ * undeclaring reach every environment in the project regardless of which one
+ * is named (`VariableService.updateDeclaration`/`undeclare` only ever
+ * rewrite the one project-wide record). It still matters for two things: the
+ * scope has to resolve to a real environment at all, and — for `rename`/
+ * `describe` only — it picks which environment's `value` comes back on the
+ * `Variable` the call answers. Left unset, the server assumes `"prod"`
+ * (`Scope.Default`), which is a 404 waiting to happen for a project that
+ * never created one; set it explicitly for any other project shape.
+ */
+export interface VariableEnvironmentOptions extends RequestOptions {
+    environment?: string;
+}
+/** Declarations within one project: `declare`, `rename`, `describe`,
+ *  `undeclare`. Values live on `EnvironmentVariables` instead. */
+export declare class ProjectVariables {
+    private readonly transport;
+    private readonly project;
+    constructor(transport: Transport, project: string);
+    declare(name: string, options?: DeclareVariableOptions): Promise<Variable>;
+    rename(name: string, to: string, options?: VariableEnvironmentOptions): Promise<Variable>;
+    describe(name: string, description: string, options?: VariableEnvironmentOptions): Promise<Variable>;
+    /** Forgets the name and every environment's value with it. */
+    undeclare(name: string, options?: VariableEnvironmentOptions): Promise<void>;
+    private updateDeclaration;
+}

package/dist/variables/project-variables.d.ts

@@ -0,0 +1,38 @@
+import type { RequestOptions } from "../request-options.js";
+import type { Transport } from "../transport/transport.js";
+import { Variable } from "./variable.js";
+/** `declare()`'s options: `environment` is where the initial `value` lands,
+ *  when one is given at all. */
+export interface DeclareVariableOptions extends RequestOptions {
+    description?: string;
+    environment?: string;
+    value?: string;
+}
+/**
+ * `rename()`/`describe()`/`undeclare()`'s options. `environment` is not
+ * load-bearing for what these three do — declaring, renaming and
+ * undeclaring reach every environment in the project regardless of which one
+ * is named (`VariableService.updateDeclaration`/`undeclare` only ever
+ * rewrite the one project-wide record). It still matters for two things: the
+ * scope has to resolve to a real environment at all, and — for `rename`/
+ * `describe` only — it picks which environment's `value` comes back on the
+ * `Variable` the call answers. Left unset, the server assumes `"prod"`
+ * (`Scope.Default`), which is a 404 waiting to happen for a project that
+ * never created one; set it explicitly for any other project shape.
+ */
+export interface VariableEnvironmentOptions extends RequestOptions {
+    environment?: string;
+}
+/** Declarations within one project: `declare`, `rename`, `describe`,
+ *  `undeclare`. Values live on `EnvironmentVariables` instead. */
+export declare class ProjectVariables {
+    private readonly transport;
+    private readonly project;
+    constructor(transport: Transport, project: string);
+    declare(name: string, options?: DeclareVariableOptions): Promise<Variable>;
+    rename(name: string, to: string, options?: VariableEnvironmentOptions): Promise<Variable>;
+    describe(name: string, description: string, options?: VariableEnvironmentOptions): Promise<Variable>;
+    /** Forgets the name and every environment's value with it. */
+    undeclare(name: string, options?: VariableEnvironmentOptions): Promise<void>;
+    private updateDeclaration;
+}

package/dist/variables/variable-declaration.d.cts

@@ -0,0 +1,10 @@
+/** The wire's `VariableView`: one declaration as one environment sees it.
+ *  `value: null` means this environment has not set it. */
+export interface VariableDeclaration {
+    name: string;
+    description: string;
+    value: string | null;
+    set_in: number;
+    created_at: string;
+    updated_at: string;
+}

package/dist/variables/variable-declaration.d.ts

@@ -0,0 +1,10 @@
+/** The wire's `VariableView`: one declaration as one environment sees it.
+ *  `value: null` means this environment has not set it. */
+export interface VariableDeclaration {
+    name: string;
+    description: string;
+    value: string | null;
+    set_in: number;
+    created_at: string;
+    updated_at: string;
+}

package/dist/variables/variable.d.cts

@@ -0,0 +1,17 @@
+import type { VariableDeclaration } from "./variable-declaration.cjs";
+/**
+ * One `{{NAME}}` declaration as one environment sees it. `value` is
+ * `null` when this environment has given it nothing — not `""`, which is a
+ * value in its own right. The name itself is never rewritten: it is
+ * case-sensitive `UPPER_SNAKE` content, not metadata.
+ */
+export declare class Variable {
+    readonly name: string;
+    readonly description: string;
+    readonly value: string | null;
+    readonly setIn: number;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    private constructor();
+    static fromWire(payload: VariableDeclaration): Variable;
+}

package/dist/variables/variable.d.ts

@@ -0,0 +1,17 @@
+import type { VariableDeclaration } from "./variable-declaration.js";
+/**
+ * One `{{NAME}}` declaration as one environment sees it. `value` is
+ * `null` when this environment has given it nothing — not `""`, which is a
+ * value in its own right. The name itself is never rewritten: it is
+ * case-sensitive `UPPER_SNAKE` content, not metadata.
+ */
+export declare class Variable {
+    readonly name: string;
+    readonly description: string;
+    readonly value: string | null;
+    readonly setIn: number;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    private constructor();
+    static fromWire(payload: VariableDeclaration): Variable;
+}