palbase 0.0.0-stage → 0.2.0

package/types/internal/src/modules/flags.d.ts

@@ -0,0 +1,957 @@
+import { type Reply, type Transport } from '../transport.js';
+/**
+ * Installations per day, platform and app version.
+ */
+export type AdoptionCurve = DailyBucket[];
+export type BatchApplied = {
+    /**
+     * Operations applied.
+     */
+    applied: number;
+};
+export type Condition = {
+    /**
+     * The value when it matches: the flag's type, inside its choices.
+     */
+    value: unknown;
+    /**
+     * The expression: comparisons over client.platform, client.locale, client.app_version, client.os_version, percentile, server.country and server.now, combined with && || and parentheses (512 characters, 16 comparisons at most).
+     */
+    when: string;
+};
+export type DailyBucket = {
+    /**
+     * The app version.
+     */
+    app_version: string;
+    /**
+     * The day (UTC).
+     */
+    day: string;
+    /**
+     * Installations.
+     */
+    installations: number;
+    /**
+     * The platform.
+     */
+    platform: string;
+};
+export type DeletedCount = {
+    /**
+     * Values removed.
+     */
+    deleted: number;
+};
+export type Delta = {
+    /**
+     * The changes, in the order they were made.
+     */
+    ops: DeltaOp[];
+    /**
+     * The version the client is current as of after applying them.
+     */
+    sync_version: string;
+};
+export type DeltaOp = {
+    /**
+     * The flag's key.
+     */
+    key: string;
+    /**
+     * put: the key's value is now value; delete: the flag is gone.
+     */
+    op: "put" | "delete";
+    /**
+     * Where the value came from.
+     */
+    source: "system" | "override";
+    /**
+     * The value (put only).
+     */
+    value?: unknown;
+    /**
+     * The change's version.
+     */
+    version: number;
+};
+/**
+ * The shared draft; absent when there is none.
+ */
+export type DraftAnswer = {
+    draft?: TemplateDraft;
+};
+/**
+ * An empty object.
+ */
+export type EmptyRequest = Record<string, never>;
+export type ErrorResponse = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Correlation ID
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying, when the refusal ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code
+     */
+    status: number;
+};
+export type Evaluations = {
+    /**
+     * The buckets' size.
+     */
+    bucket: "hour" | "day";
+    /**
+     * The flag asked for, or the 20 evaluated most, most first; none counted, none here.
+     */
+    flags: FlagEvaluations[];
+    /**
+     * The reads per bucket, oldest first.
+     */
+    reads: ReadsBucket[];
+    /**
+     * The first bucket's start, Unix milliseconds.
+     */
+    since_ms: number;
+    /**
+     * The window read.
+     */
+    window_seconds: number;
+};
+export type EvaluationsBucket = {
+    /**
+     * The bucket's start, Unix milliseconds.
+     */
+    bucket_ms: number;
+    /**
+     * Counter: the evaluations.
+     */
+    evaluations: number;
+    /**
+     * With flag: the value served, as the operation says, or other. Absent in a total.
+     */
+    value?: string;
+};
+export type Flag = {
+    /**
+     * Targeting, in order, first match wins (8 at most).
+     */
+    conditions: Condition[] | null;
+    /**
+     * When the flag was first defined.
+     */
+    created_at: string;
+    /**
+     * What the flag is for.
+     */
+    description: string;
+    /**
+     * The flag's key.
+     */
+    key: string;
+    /**
+     * A Palbase-managed flag (palbase.*): its type is fixed and it is not deleted.
+     */
+    managed: boolean;
+    /**
+     * Whether the flag may be targeted.
+     */
+    supports_conditions: boolean;
+    /**
+     * When it last changed.
+     */
+    updated_at: string;
+    /**
+     * The default: what every reader gets when no condition matches and they have no value of their own (8 KB at most).
+     */
+    value: unknown;
+    /**
+     * What the flag's values are.
+     */
+    value_type: "bool" | "number" | "string" | "object";
+    /**
+     * A string flag's allowed choices; every value — the default, the conditions', the users' — is one of them.
+     */
+    variants: string[] | null;
+    /**
+     * The version of the flag's last change.
+     */
+    version: number;
+};
+export type FlagDefinition = {
+    /**
+     * Targeting, in order, first match wins (8 at most).
+     */
+    conditions?: Condition[] | null;
+    /**
+     * What the flag is for.
+     */
+    description?: string;
+    /**
+     * The default: what every reader gets when no condition matches and they have no value of their own (8 KB at most).
+     */
+    value: unknown;
+    /**
+     * What the flag's values are.
+     */
+    value_type: "bool" | "number" | "string" | "object";
+    /**
+     * A string flag's allowed choices; every value — the default, the conditions', the users' — is one of them.
+     */
+    variants?: string[] | null;
+};
+export type FlagEvaluations = {
+    /**
+     * The flag's key.
+     */
+    key: string;
+    /**
+     * Per bucket, oldest first; with flag, per value within it, the most evaluated first.
+     */
+    rows: EvaluationsBucket[];
+    /**
+     * Counter: its evaluations over the window.
+     */
+    total: number;
+};
+/**
+ * The project's flags, by key.
+ */
+export type FlagList = Flag[];
+export type FlagValues = {
+    /**
+     * When the answer was made.
+     */
+    fetched_at: string;
+    /**
+     * Each flag's value, by key.
+     */
+    values: {
+        [key: string]: unknown;
+    };
+};
+export type InstallationDistribution = {
+    /**
+     * By platform and app version.
+     */
+    buckets: VersionBucket[];
+    /**
+     * Today's reads that named no installation.
+     */
+    unidentified: number;
+};
+/**
+ * A refusal, or the draft's issues.
+ */
+export type PublishConflict = ErrorResponse | TemplateValidationFailed;
+export type PublishRequest = {
+    /**
+     * Why (2048 characters at most).
+     */
+    note?: string;
+};
+export type PublishResult = {
+    template: TemplateVersion;
+    /**
+     * The draft changed nothing; nothing was published.
+     */
+    unchanged: boolean;
+};
+export type ReadsBucket = {
+    /**
+     * The bucket's start, Unix milliseconds.
+     */
+    bucket_ms: number;
+    /**
+     * Counter: every read a client made, as it is metered — a snapshot, a delta, its values; answered, not modified or told to resync.
+     */
+    reads: number;
+    /**
+     * Counter: of those reads, the snapshots that named no installation (X-Palbase-Installation), as a web app's.
+     */
+    unidentified: number;
+};
+export type Snapshot = {
+    /**
+     * The hash of what the answer depends on besides the flags (client context, country, user, time conditions).
+     */
+    context_hash: string;
+    /**
+     * When the answer was made.
+     */
+    fetched_at: string;
+    /**
+     * Where each value came from: the flag (system) or the user's own (override).
+     */
+    sources: {
+        [key: string]: "system" | "override";
+    };
+    /**
+     * The version the answer is current as of: the delta's since.
+     */
+    sync_version: string;
+    /**
+     * Each flag's value, by key.
+     */
+    values: {
+        [key: string]: unknown;
+    };
+};
+export type TemplateCapabilities = {
+    /**
+     * Publishing can be turned on.
+     */
+    activation_available: boolean;
+    /**
+     * Publishing is on.
+     */
+    publish_enabled: boolean;
+};
+export type TemplateChange = {
+    after?: FlagDefinition;
+    before?: FlagDefinition;
+    /**
+     * The fields that change.
+     */
+    changed_fields: string[];
+    /**
+     * The parameter.
+     */
+    key: string;
+    /**
+     * What the draft does to it.
+     */
+    kind: "added" | "changed" | "removed";
+    /**
+     * Users' values of the parameter.
+     */
+    override_count: number;
+};
+/**
+ * Every definition, by key.
+ */
+export type TemplateDocument = {
+    [key: string]: FlagDefinition;
+};
+export type TemplateDraft = {
+    /**
+     * The version it started from.
+     */
+    base_version: string;
+    /**
+     * When it was started.
+     */
+    created_at: string;
+    /**
+     * Who started it.
+     */
+    created_by: string;
+    definitions: TemplateDocument;
+    /**
+     * The draft.
+     */
+    id: string;
+    /**
+     * The version it restores.
+     */
+    restored_from?: string;
+    /**
+     * Its revision: every write is the next.
+     */
+    revision: string;
+    /**
+     * When it was last written.
+     */
+    updated_at: string;
+    /**
+     * Who last wrote it.
+     */
+    updated_by: string;
+};
+export type TemplateHistoryPage = {
+    /**
+     * The version in force.
+     */
+    active_version: string;
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * Newest first.
+     */
+    versions: TemplateVersionSummary[];
+};
+export type TemplateIssue = {
+    /**
+     * The issue.
+     */
+    code: string;
+    /**
+     * The parameter, when the issue is one's.
+     */
+    key?: string;
+    /**
+     * What to do about it.
+     */
+    message: string;
+};
+export type TemplateReview = {
+    /**
+     * The version in force.
+     */
+    active_version: string;
+    /**
+     * The version it started from.
+     */
+    base_version: string;
+    /**
+     * No issues.
+     */
+    can_publish: boolean;
+    /**
+     * What changes.
+     */
+    changes: TemplateChange[];
+    /**
+     * The draft.
+     */
+    draft_id: string;
+    /**
+     * Its revision.
+     */
+    draft_revision: string;
+    /**
+     * What keeps it from being published.
+     */
+    issues: TemplateIssue[];
+    /**
+     * The version it restores.
+     */
+    restored_from?: string;
+};
+export type TemplateValidationFailed = {
+    /**
+     * template_validation_failed
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * What keeps the draft from being published.
+     */
+    issues: TemplateIssue[];
+    /**
+     * Correlation ID
+     */
+    request_id?: string;
+    /**
+     * HTTP status code
+     */
+    status?: number;
+};
+export type TemplateVersion = {
+    /**
+     * Who published it.
+     */
+    actor: string;
+    /**
+     * When it was published.
+     */
+    created_at: string;
+    definitions: TemplateDocument;
+    /**
+     * baseline: what was live at activation; publish; restore.
+     */
+    kind: "baseline" | "publish" | "restore";
+    /**
+     * The publication's note.
+     */
+    note: string;
+    /**
+     * The version it followed.
+     */
+    parent_version?: string;
+    /**
+     * The version it restored.
+     */
+    restored_from?: string;
+    /**
+     * The version.
+     */
+    version: string;
+};
+export type TemplateVersionSummary = {
+    /**
+     * Who published it.
+     */
+    actor: string;
+    /**
+     * When it was published.
+     */
+    created_at: string;
+    /**
+     * baseline, publish or restore.
+     */
+    kind: "baseline" | "publish" | "restore";
+    /**
+     * The note.
+     */
+    note: string;
+    /**
+     * The version it followed.
+     */
+    parent_version?: string;
+    /**
+     * The version it restored.
+     */
+    restored_from?: string;
+    /**
+     * The version.
+     */
+    version: string;
+};
+export type UserValue = {
+    /**
+     * The user's value: the flag's type, inside its choices.
+     */
+    value: unknown;
+};
+export type UserValueAnswer = {
+    /**
+     * The flag's key.
+     */
+    key: string;
+    /**
+     * override: the user's own; system: the flag's, resolved for the user.
+     */
+    source: "system" | "override";
+    /**
+     * The value.
+     */
+    value: unknown;
+};
+export type UserValues = {
+    /**
+     * Each flag's value, by key.
+     */
+    values?: {
+        [key: string]: unknown;
+    };
+};
+export type UserValuesBatch = {
+    /**
+     * 1000 at most.
+     */
+    operations: UserValuesOperation[];
+};
+export type UserValuesOperation = {
+    /**
+     * The user's id.
+     */
+    user_id: string;
+    /**
+     * Each flag's value, by key.
+     */
+    values: {
+        [key: string]: unknown;
+    };
+};
+export type VersionBucket = {
+    /**
+     * The app version.
+     */
+    app_version: string;
+    /**
+     * Installations.
+     */
+    installations: number;
+    /**
+     * The platform.
+     */
+    platform: string;
+};
+/** Palbase Flags */
+export declare function client(t: Transport): {
+    /**
+     * Read the flags' values
+     *
+     * Every flag's value for the reader, alone. Resolved for the reader: a signed-in user's token (with the publishable key) makes the answer theirs — their own values first, then the first condition of each flag that matches, then its default. Conditions read what the client declares (platform, versions, locale), the share of users a percentile picks (signed-in users only), the country of the address the edge saw, and the server's clock.
+     */
+    getValues(input?: {
+        headers?: {
+            "X-Platform"?: string; /** The operating system's version (client.os_version). */
+            "X-OS-Version"?: string; /** The app's version (client.app_version). */
+            "X-Palbase-Client-Version"?: string; /** The client's languages; the first is client.locale. */
+            "Accept-Language"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, FlagValues>>;
+    /**
+     * Set many users' values
+     *
+     * Sets values for many users at once (1000 operations at most): all of them, or none.
+     */
+    batchUserValues(input: {
+        body: UserValuesBatch; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, BatchApplied>>;
+    /**
+     * Read what changed
+     *
+     * What changed for the reader since a version, in order: a value put, or a flag deleted. A client whose answer may no longer be its own — its context, country or user changed, or a time condition turned (its If-None-Match says) — or whose version is older than the deletions still kept (30 days), is answered 410 and takes a snapshot. Resolved for the reader: a signed-in user's token (with the publishable key) makes the answer theirs — their own values first, then the first condition of each flag that matches, then its default. Conditions read what the client declares (platform, versions, locale), the share of users a percentile picks (signed-in users only), the country of the address the edge saw, and the server's clock.
+     */
+    getDelta(input?: {
+        query?: {
+            since?: number;
+        };
+        headers?: {
+            "If-None-Match"?: string; /** The client's platform (client.platform). */
+            "X-Platform"?: string; /** The operating system's version (client.os_version). */
+            "X-OS-Version"?: string; /** The app's version (client.app_version). */
+            "X-Palbase-Client-Version"?: string; /** The client's languages; the first is client.locale. */
+            "Accept-Language"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Delta> | Reply<304, undefined>>;
+    /**
+     * Read the reads and evaluations
+     *
+     * How often the project's client apps read its flags, and the value each flag's answers carried, per hour or per UTC day over a window: what the project's charts draw.
+     *
+     * An evaluation is a flag's value carried in an answer to a client app: each flag of a snapshot or a values read answered 200, and each flag a delta answered 200 leaves its client holding (the key's last op, when it is a put). Values are resolved on the server, so this is what was served; a client reusing a value it holds is not seen. A snapshot or a delta answered 304, a delta answered 410, and the project's server reading a user's values (`GET /flags/users/{user_id}`) carry none.
+     *
+     * Every number is a counter, summed over the module's replicas; none is a gauge. A bucket nothing was counted in is absent from `reads` and from a flag's `rows`: it is zero. Buckets start on the hour or at midnight UTC; the first is the one the window starts in (`since_ms`).
+     *
+     * With `flag`, that flag's evaluations per bucket and value. A value is the served value's JSON as it is kept (`true`, `"dark"`, `{"plan": "pro"}`); one longer than 128 bytes is cut, and `…` and 8 hex characters of its SHA-256 follow the cut. A bucket counts its first 10 values by name and any further one as `other`, which no JSON text is; an answer names at most 10 per bucket, the most evaluated. Without `flag`, the 20 flags evaluated most over the window, each with its total per bucket.
+     *
+     * Counts are written every minute: the last one may not be in yet, and a replica that stops without its last write loses at most that minute. Kept: hourly evaluations 15 days, daily evaluations and the hourly reads 91 — `bucket=hour` reads up to 14 days back, `bucket=day` up to 90.
+     */
+    getEvaluations(input?: {
+        query?: {
+            window_seconds?: number; /** hour, or day (UTC) (hour). */
+            bucket?: "hour" | "day"; /** A flag's key: its evaluations by value. Without it, the 20 flags evaluated most, with their totals. */
+            flag?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Evaluations>>;
+    /**
+     * Read the builds in use
+     *
+     * The installations that read their flags in the last day, by platform and app version, and the reads that named no installation today.
+     */
+    getCurrentInstallations(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, InstallationDistribution>>;
+    /**
+     * Read the adoption curve
+     *
+     * Installations per day, platform and app version, for the last days (kept 90).
+     */
+    getInstallationsDaily(input?: {
+        query?: {
+            days?: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, AdoptionCurve>>;
+    /**
+     * Take a snapshot
+     *
+     * Every flag's value for the reader, where each came from, and the version it is current as of — what a client starts from, then keeps up to date with deltas. Resolved for the reader: a signed-in user's token (with the publishable key) makes the answer theirs — their own values first, then the first condition of each flag that matches, then its default. Conditions read what the client declares (platform, versions, locale), the share of users a percentile picks (signed-in users only), the country of the address the edge saw, and the server's clock. The answer's ETag names the version and everything else it depends on; sent back as If-None-Match, an unchanged answer is 304. Each read is metered (flags.reads).
+     */
+    getSnapshot(input?: {
+        headers?: {
+            "If-None-Match"?: string; /** The app installation's id (64 characters at most): counted for version adoption. */
+            "X-Palbase-Installation"?: string; /** The client's platform (client.platform). */
+            "X-Platform"?: string; /** The operating system's version (client.os_version). */
+            "X-OS-Version"?: string; /** The app's version (client.app_version). */
+            "X-Palbase-Client-Version"?: string; /** The client's languages; the first is client.locale. */
+            "Accept-Language"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Snapshot> | Reply<304, undefined>>;
+    /**
+     * List the flags
+     *
+     * Every flag the project defines (200 at most), by key.
+     */
+    listDefinitions(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, FlagList>>;
+    /**
+     * Read a flag
+     *
+     * One flag's definition.
+     */
+    getDefinition(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Flag>>;
+    /**
+     * Define a flag
+     *
+     * Defines a flag, or changes one (a deleted one comes back): its type, its default, the choices a string flag allows, and the conditions — first match wins — that give another value. Refused while publishing is on (templates), when it would change the type under users' values or leave a user's value outside the choices, and past 200 flags. Every reader is told (flags:<ref>).
+     */
+    putDefinition(input: {
+        path: {
+            key: string;
+        };
+        body: FlagDefinition; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Flag>>;
+    /**
+     * Delete a flag
+     *
+     * Deletes a flag and every user's value of it; a client syncing is told. A Palbase-managed flag is not deleted.
+     */
+    deleteDefinition(input: {
+        path: {
+            key: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Turn publishing on
+     *
+     * Turns publishing on, one way: the live flags become version 1, and from then on definitions change only through a published draft (a direct write is refused, 409 publish_required). Turning it on again answers the active version.
+     */
+    activateTemplates(input: {
+        body: EmptyRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TemplateVersion>>;
+    /**
+     * Read the active version
+     *
+     * The version in force, with every definition.
+     */
+    getActiveTemplate(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TemplateVersion>>;
+    /**
+     * Read the publishing state
+     *
+     * Whether publishing is on, and whether it can be turned on.
+     */
+    getTemplateCapabilities(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TemplateCapabilities>>;
+    /**
+     * Read the draft
+     *
+     * The project's shared draft, or none.
+     */
+    getTemplateDraft(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DraftAnswer>>;
+    /**
+     * Start a draft
+     *
+     * Starts the shared draft from the active version named in If-Match.
+     */
+    createTemplateDraft(input: {
+        headers: {
+            "If-Match": string;
+        };
+        body: EmptyRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, DraftAnswer>>;
+    /**
+     * Discard the draft
+     *
+     * Discards the draft named in If-Match.
+     */
+    discardTemplateDraft(input: {
+        headers: {
+            "If-Match": string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Write a draft parameter
+     *
+     * Writes one parameter of the draft named in If-Match (the next revision); validated as a definition is.
+     */
+    putTemplateParameter(input: {
+        path: {
+            key: string;
+        };
+        headers: {
+            "If-Match": string;
+        };
+        body: FlagDefinition; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DraftAnswer>>;
+    /**
+     * Remove a draft parameter
+     *
+     * Removes one parameter of the draft named in If-Match. A Palbase-managed one stays.
+     */
+    removeTemplateParameter(input: {
+        path: {
+            key: string;
+        };
+        headers: {
+            "If-Match": string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DraftAnswer>>;
+    /**
+     * Review the draft
+     *
+     * What publishing the draft would do: each change against the active version, how many users' values each touches, and the issues that keep it from being published.
+     */
+    reviewTemplateDraft(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TemplateReview>>;
+    /**
+     * Publish the draft
+     *
+     * Publishes the draft named in If-Match: its definitions become the live ones and the next version in one transaction, and every reader is told. The same Idempotency-Key answers the first publication again; an unchanged draft publishes nothing. A draft with issues is refused (409 template_validation_failed) with the issues.
+     */
+    publishTemplate(input: {
+        headers: {
+            "If-Match": string; /** One publication's key: the same key answers its first publication again (1 to 128 printable ASCII). */
+            "Idempotency-Key": string;
+        };
+        body: PublishRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PublishResult>>;
+    /**
+     * Read a publication's receipt
+     *
+     * A publication's committed answer, by the same draft, key and note — for a client that lost the response.
+     */
+    getPublishReceipt(input: {
+        headers: {
+            "If-Match": string; /** One publication's key: the same key answers its first publication again (1 to 128 printable ASCII). */
+            "Idempotency-Key": string;
+        };
+        body: PublishRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PublishResult>>;
+    /**
+     * Restore a version
+     *
+     * Starts the shared draft from an earlier version, expecting the active version named in If-Match; published, it becomes the next version.
+     */
+    restoreTemplateVersion(input: {
+        path: {
+            version: string;
+        };
+        headers: {
+            "If-Match": string;
+        };
+        body: EmptyRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, DraftAnswer>>;
+    /**
+     * List the versions
+     *
+     * The published versions, newest first, paged.
+     */
+    listTemplateVersions(input?: {
+        query?: {
+            limit?: number; /** A next_cursor this list answered. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TemplateHistoryPage>>;
+    /**
+     * Read a version
+     *
+     * One published version, with every definition.
+     */
+    getTemplateVersion(input: {
+        path: {
+            version: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TemplateVersion>>;
+    /**
+     * Read a user's values
+     *
+     * Every flag's value for one user, as their client would read it (percentiles are the user's; the client context is this request's).
+     */
+    getUserValues(input: {
+        path: {
+            user_id: string;
+        };
+        headers?: {
+            "X-Platform"?: string; /** The operating system's version (client.os_version). */
+            "X-OS-Version"?: string; /** The app's version (client.app_version). */
+            "X-Palbase-Client-Version"?: string; /** The client's languages; the first is client.locale. */
+            "Accept-Language"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, FlagValues>>;
+    /**
+     * Set a user's values
+     *
+     * Gives one user their own values for flags (1000 at most), each checked against its flag's type and choices. The user's readers are told (flags:<ref>:<user_id>).
+     */
+    putUserValues(input: {
+        path: {
+            user_id: string;
+        };
+        body: UserValues; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, UserValues>>;
+    /**
+     * Remove a user's values
+     *
+     * Removes every value of the user's own; their flags resolve as anyone's again.
+     */
+    deleteUserValues(input: {
+        path: {
+            user_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DeletedCount>>;
+    /**
+     * Set a user's value
+     *
+     * Gives one user their own value for a flag, checked against its type and choices.
+     */
+    putUserValue(input: {
+        path: {
+            user_id: string; /** The flag's key: dot-separated segments of a letter then letters, digits and underscores; 128 characters at most. */
+            key: string;
+        };
+        body: UserValue; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, UserValueAnswer>>;
+    /**
+     * Remove a user's value
+     *
+     * Removes the user's own value for a flag; the answer is what resolves for them now.
+     */
+    deleteUserValue(input: {
+        path: {
+            user_id: string; /** The flag's key: dot-separated segments of a letter then letters, digits and underscores; 128 characters at most. */
+            key: string;
+        };
+        headers?: {
+            "X-Platform"?: string; /** The operating system's version (client.os_version). */
+            "X-OS-Version"?: string; /** The app's version (client.app_version). */
+            "X-Palbase-Client-Version"?: string; /** The client's languages; the first is client.locale. */
+            "Accept-Language"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, UserValueAnswer>>;
+};
+export type Client = ReturnType<typeof client>;