@distilled.cloud/celld 0.0.0-placeholder → 1.0.0-rc.13

package/lib/services/runtime.d.ts

@@ -0,0 +1,686 @@
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import { type CelldOpError, type CelldOpContext } from "../protocol.ts";
+export type { CelldOpError, CelldOpContext };
+declare const D1ExecutionError_base: S.Class<D1ExecutionError, S.TaggedStruct<"D1ExecutionError", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
+/** The native D1 engine rejected SQL execution. Exec and prepared-statement requests may have already committed earlier statements; this error does not authorize automatic mutation replay. */
+export declare class D1ExecutionError extends /*@__PURE__*/ D1ExecutionError_base {
+}
+declare const PeerIncompatibleVersion_base: S.Class<PeerIncompatibleVersion, S.TaggedStruct<"PeerIncompatibleVersion", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError>;
+/** peer protocol version is incompatible */
+export declare class PeerIncompatibleVersion extends /*@__PURE__*/ PeerIncompatibleVersion_base {
+}
+declare const PeerReplayRejected_base: S.Class<PeerReplayRejected, S.TaggedStruct<"PeerReplayRejected", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+/** peer request replay rejected */
+export declare class PeerReplayRejected extends /*@__PURE__*/ PeerReplayRejected_base {
+}
+declare const PeerWrongTarget_base: S.Class<PeerWrongTarget, S.TaggedStruct<"PeerWrongTarget", {
+    readonly message: any;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
+/** peer request targets a different node session */
+export declare class PeerWrongTarget extends /*@__PURE__*/ PeerWrongTarget_base {
+}
+export type KvDeleteOperation = "delete";
+export declare const KvDeleteOperation: any;
+export type Strings = Array<string>;
+export declare const Strings: S.Schema<Strings>;
+export interface DeleteKvInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: KvDeleteOperation | (string & {});
+    keys: Strings;
+}
+export declare const DeleteKvInput: S.Schema<DeleteKvInput>;
+export interface OkResult {
+    ok: boolean;
+}
+export declare const OkResult: S.Schema<OkResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface DeleteKvOutput {
+    result: OkResult;
+}
+export declare const DeleteKvOutput: S.Schema<DeleteKvOutput>;
+export interface D1ExecPayload {
+    sql: string;
+    rows?: boolean;
+}
+export declare const D1ExecPayload: S.Schema<D1ExecPayload>;
+export interface ExecD1Input {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    exec: D1ExecPayload;
+}
+export declare const ExecD1Input: S.Schema<ExecD1Input>;
+export type JsonValues = Array<unknown>;
+export declare const JsonValues: S.Schema<JsonValues>;
+export type Rows = Array<JsonValues>;
+export declare const Rows: S.Schema<Rows>;
+/** Native SQL engine result; row values and engine metadata retain their JSON types. */
+export interface D1ResultSet {
+    columns?: Strings;
+    rows?: Rows;
+    meta?: unknown;
+}
+export declare const D1ResultSet: S.Schema<D1ResultSet>;
+export type D1ResultSets = Array<D1ResultSet>;
+export declare const D1ResultSets: S.Schema<D1ResultSets>;
+/** Duration is in milliseconds. Result sets are present only when exec.rows is true. */
+export interface ExecD1Result {
+    count: number;
+    duration: number;
+    results?: D1ResultSets;
+}
+export declare const ExecD1Result: S.Schema<ExecD1Result>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface ExecD1Output {
+    result: ExecD1Result;
+}
+export declare const ExecD1Output: S.Schema<ExecD1Output>;
+export interface D1Statement {
+    sql: string;
+    params?: JsonValues;
+    first?: boolean;
+}
+export declare const D1Statement: S.Schema<D1Statement>;
+export type D1StatementList = Array<D1Statement>;
+export declare const D1StatementList: S.Schema<D1StatementList>;
+export interface ExecuteD1StatementsInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    statements: D1StatementList;
+}
+export declare const ExecuteD1StatementsInput: S.Schema<ExecuteD1StatementsInput>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface ExecuteD1StatementsOutput {
+    result: D1ResultSets;
+}
+export declare const ExecuteD1StatementsOutput: S.Schema<ExecuteD1StatementsOutput>;
+export type KvGetOperation = "get";
+export declare const KvGetOperation: any;
+export interface GetKvInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: KvGetOperation | (string & {});
+    key: string;
+}
+export declare const GetKvInput: S.Schema<GetKvInput>;
+export interface GetKvResult {
+    found: boolean;
+    /** A JSON array of byte integers for inline values, or a base64 string for large values. Absent when found is false. */
+    value?: unknown;
+    /** base64 for large values; absent for inline byte arrays. */
+    value_encoding?: string;
+    tag?: string;
+    /** Stored JSON text, not a decoded metadata object. May be null. */
+    metadata?: string | null;
+    /** Expiration in Unix milliseconds; may be null. */
+    expiration?: number | null;
+}
+export declare const GetKvResult: S.Schema<GetKvResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface GetKvOutput {
+    result: GetKvResult;
+}
+export declare const GetKvOutput: S.Schema<GetKvOutput>;
+export type GetKvInfoOperation = "info";
+export declare const GetKvInfoOperation: any;
+export interface GetKvInfoInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: GetKvInfoOperation | (string & {});
+}
+export declare const GetKvInfoInput: S.Schema<GetKvInfoInput>;
+export interface GetKvInfoResult {
+    live: number;
+    bytes: number;
+    stored: number;
+}
+export declare const GetKvInfoResult: S.Schema<GetKvInfoResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface GetKvInfoOutput {
+    result: GetKvInfoResult;
+}
+export declare const GetKvInfoOutput: S.Schema<GetKvInfoOutput>;
+export type GetQueueInfoOperation = "info";
+export declare const GetQueueInfoOperation: any;
+export interface GetQueueInfoInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: GetQueueInfoOperation | (string & {});
+}
+export declare const GetQueueInfoInput: S.Schema<GetQueueInfoInput>;
+export interface GetQueueInfoResult {
+    backlog_count: number;
+    backlog_bytes: number;
+    /** Unix milliseconds; null when no message exists. */
+    oldest_message_timestamp?: number | null;
+    stored: number;
+    paused: boolean;
+}
+export declare const GetQueueInfoResult: S.Schema<GetQueueInfoResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface GetQueueInfoOutput {
+    result: GetQueueInfoResult;
+}
+export declare const GetQueueInfoOutput: S.Schema<GetQueueInfoOutput>;
+export type KvListOperation = "list";
+export declare const KvListOperation: any;
+export interface ListKvInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: KvListOperation | (string & {});
+    prefix?: string;
+    limit: number;
+    /** Exclusive last key name from the previous page, not a binding cursor. */
+    after?: string;
+}
+export declare const ListKvInput: S.Schema<ListKvInput>;
+export interface KvKey {
+    name: string;
+    /** Stored JSON text; may be null. */
+    metadata?: string | null;
+    /** Unix milliseconds; may be null. */
+    expiration?: number | null;
+}
+export declare const KvKey: S.Schema<KvKey>;
+export type KvKeys = Array<KvKey>;
+export declare const KvKeys: S.Schema<KvKeys>;
+export interface ListKvResult {
+    keys: KvKeys;
+    complete: boolean;
+}
+export declare const ListKvResult: S.Schema<ListKvResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface ListKvOutput {
+    result: ListKvResult;
+}
+export declare const ListKvOutput: S.Schema<ListKvOutput>;
+export interface D1Migration {
+    name: string;
+    sql: string;
+    /** Defaults to d1_migrations when omitted or empty. */
+    table?: string;
+}
+export declare const D1Migration: S.Schema<D1Migration>;
+export interface MigrateD1Input {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    migrate: D1Migration;
+}
+export declare const MigrateD1Input: S.Schema<MigrateD1Input>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface MigrateD1Output {
+    result: unknown;
+}
+export declare const MigrateD1Output: S.Schema<MigrateD1Output>;
+export type QueuePauseOperation = "pause";
+export declare const QueuePauseOperation: any;
+export interface PauseQueueInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: QueuePauseOperation | (string & {});
+}
+export declare const PauseQueueInput: S.Schema<PauseQueueInput>;
+export interface QueuePausedResult {
+    backlog_count: number;
+    backlog_bytes: number;
+    /** Unix milliseconds; null when no message exists. */
+    oldest_message_timestamp?: number | null;
+    paused: boolean;
+}
+export declare const QueuePausedResult: S.Schema<QueuePausedResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface PauseQueueOutput {
+    result: QueuePausedResult;
+}
+export declare const PauseQueueOutput: S.Schema<PauseQueueOutput>;
+export type PeekQueueOperation = "peek";
+export declare const PeekQueueOperation: any;
+export interface PeekQueueInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: PeekQueueOperation | (string & {});
+    /** Defaults to 10; valid values are 1 through 100. */
+    limit?: number;
+}
+export declare const PeekQueueInput: S.Schema<PeekQueueInput>;
+export interface QueueMessage {
+    id: string;
+    body_base64: string;
+    content_type: string;
+    size: number;
+    enqueued_at: number;
+    visible_at: number;
+    attempts: number;
+    /** moving, purging, leased, visible or delayed. */
+    state: string;
+    /** Unix milliseconds; null unless actively leased. */
+    leased_until?: number | null;
+    /** May be null. */
+    transfer_target?: string | null;
+    /** May be null. */
+    dead_letter_source?: string | null;
+}
+export declare const QueueMessage: S.Schema<QueueMessage>;
+export type QueueMessages = Array<QueueMessage>;
+export declare const QueueMessages: S.Schema<QueueMessages>;
+export interface PeekQueueResult {
+    messages: QueueMessages;
+}
+export declare const PeekQueueResult: S.Schema<PeekQueueResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface PeekQueueOutput {
+    result: PeekQueueResult;
+}
+export declare const PeekQueueOutput: S.Schema<PeekQueueOutput>;
+export type QueuePurgeOperation = "purge";
+export declare const QueuePurgeOperation: any;
+export interface PurgeQueueInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: QueuePurgeOperation | (string & {});
+}
+export declare const PurgeQueueInput: S.Schema<PurgeQueueInput>;
+export interface QueueMetrics {
+    backlog_count: number;
+    backlog_bytes: number;
+    /** Unix milliseconds; null when no message exists. */
+    oldest_message_timestamp?: number | null;
+}
+export declare const QueueMetrics: S.Schema<QueueMetrics>;
+export interface PurgeQueueResult {
+    deleted: number;
+    leased: number;
+    metrics: QueueMetrics;
+}
+export declare const PurgeQueueResult: S.Schema<PurgeQueueResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface PurgeQueueOutput {
+    result: PurgeQueueResult;
+}
+export declare const PurgeQueueOutput: S.Schema<PurgeQueueOutput>;
+export type KvPutOperation = "put";
+export declare const KvPutOperation: any;
+export type Bytes = Array<number>;
+export declare const Bytes: S.Schema<Bytes>;
+export interface PutKvInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: KvPutOperation | (string & {});
+    key: string;
+    /** Defaults to bytes. */
+    tag?: string;
+    /** JSON-encoded metadata text, not an object. */
+    metadata?: string;
+    /** Absolute Unix expiration in seconds. */
+    expiration?: number;
+    /** Relative expiry in seconds. The wire key is expirationTtl, as used by the source handler. */
+    expiration_ttl?: number;
+    value: Bytes;
+}
+export declare const PutKvInput: S.Schema<PutKvInput>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface PutKvOutput {
+    result: OkResult;
+}
+export declare const PutKvOutput: S.Schema<PutKvOutput>;
+export type PutKvBase64Operation = "put-base64";
+export declare const PutKvBase64Operation: any;
+export interface PutKvBase64Input {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: PutKvBase64Operation | (string & {});
+    key: string;
+    /** Defaults to bytes. */
+    tag?: string;
+    /** JSON-encoded metadata text, not an object. */
+    metadata?: string;
+    /** Absolute Unix expiration in seconds. */
+    expiration?: number;
+    /** Relative expiry in seconds. The wire key is expirationTtl, as used by the source handler. */
+    expiration_ttl?: number;
+    value: string;
+}
+export declare const PutKvBase64Input: S.Schema<PutKvBase64Input>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface PutKvBase64Output {
+    result: OkResult;
+}
+export declare const PutKvBase64Output: S.Schema<PutKvBase64Output>;
+export type RedriveQueueOperation = "redrive";
+export declare const RedriveQueueOperation: any;
+export interface RedriveQueueInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: RedriveQueueOperation | (string & {});
+    /** Defaults to 100; valid values are 1 through 100. */
+    limit?: number;
+}
+export declare const RedriveQueueInput: S.Schema<RedriveQueueInput>;
+export interface RedriveQueueResult {
+    redriven: number;
+    metrics: QueueMetrics;
+}
+export declare const RedriveQueueResult: S.Schema<RedriveQueueResult>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface RedriveQueueOutput {
+    result: RedriveQueueResult;
+}
+export declare const RedriveQueueOutput: S.Schema<RedriveQueueOutput>;
+export type QueueResumeOperation = "resume";
+export declare const QueueResumeOperation: any;
+export interface ResumeQueueInput {
+    /** Reserved-class cell scope derived by Celld, not a database, namespace or queue display name. */
+    scope: string;
+    /** Optional cell identity name; include the exact encoded query string in the peer signature. */
+    name?: string;
+    /** Peer protocol version; send the string 5. */
+    peer_version: string;
+    /** Source node name or operator identity, validated as a node name. */
+    peer_source: string;
+    /** Exact addressed node session identity, not the cell scope. */
+    peer_target: string;
+    /** Decimal Unix milliseconds as text; accepted within a 30000 ms clock window. */
+    peer_timestamp: string;
+    /** A fresh 16-byte nonce encoded as 32 hexadecimal characters; reuse is rejected. */
+    peer_nonce: string;
+    /** Lowercase SHA-256 hex digest of the exact serialized HTTP request body bytes. */
+    peer_body_sha256: string;
+    /** HMAC-SHA256 hex signature over newline-separated domain cells-peer-request-v1, version 5, method POST, exact path and query, body hash, source, target, timestamp and nonce, with no trailing newline. */
+    peer_signature: string;
+    op: QueueResumeOperation | (string & {});
+}
+export declare const ResumeQueueInput: S.Schema<ResumeQueueInput>;
+/** The actual HTTP JSON envelope is {"result": ...}; nested arrays or scalars are not top-level raw responses. */
+export interface ResumeQueueOutput {
+    result: QueuePausedResult;
+}
+export declare const ResumeQueueOutput: S.Schema<ResumeQueueOutput>;
+export type DeleteKvError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Delete a list of keys from a reserved KV namespace. */
+export declare const deleteKv: API.OperationMethod<DeleteKvInput, DeleteKvOutput, DeleteKvError, CelldOpContext>;
+export type ExecD1Error = D1ExecutionError | PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Execute SQL against a reserved D1 cell with the JSON body {"exec":{"sql":...,"rows":...}}. */
+export declare const execD1: API.OperationMethod<ExecD1Input, ExecD1Output, ExecD1Error, CelldOpContext>;
+export type ExecuteD1StatementsError = D1ExecutionError | PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Run prepared statements sequentially, not as an atomic batch. The body key is statements; each params entry retains its native JSON type. */
+export declare const executeD1Statements: API.OperationMethod<ExecuteD1StatementsInput, ExecuteD1StatementsOutput, ExecuteD1StatementsError, CelldOpContext>;
+export type GetKvError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Read one key from a reserved KV namespace. A missing key returns result.found=false. */
+export declare const getKv: API.OperationMethod<GetKvInput, GetKvOutput, GetKvError, CelldOpContext>;
+export type GetKvInfoError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Return live key count, live bytes and total stored key count. */
+export declare const getKvInfo: API.OperationMethod<GetKvInfoInput, GetKvInfoOutput, GetKvInfoError, CelldOpContext>;
+export type GetQueueInfoError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Reserved Queue operator request with JSON op=info. This is not the private Queue RPC or settlement endpoint. */
+export declare const getQueueInfo: API.OperationMethod<GetQueueInfoInput, GetQueueInfoOutput, GetQueueInfoError, CelldOpContext>;
+export type ListKvError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** List keys in a reserved KV namespace. Metadata remains JSON text and expiration is in milliseconds. */
+export declare const listKv: API.OperationMethod<ListKvInput, ListKvOutput, ListKvError, CelldOpContext>;
+export type MigrateD1Error = D1ExecutionError | PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Apply a migration atomically with its bookkeeping insert. The result is the SQL engine native JSON value; no RPC action wrapper is sent. */
+export declare const migrateD1: API.OperationMethod<MigrateD1Input, MigrateD1Output, MigrateD1Error, CelldOpContext>;
+export type PauseQueueError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Reserved Queue operator request with JSON op=pause. This is not the private Queue RPC or settlement endpoint. */
+export declare const pauseQueue: API.OperationMethod<PauseQueueInput, PauseQueueOutput, PauseQueueError, CelldOpContext>;
+export type PeekQueueError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Reserved Queue operator request with JSON op=peek. This is not the private Queue RPC or settlement endpoint. */
+export declare const peekQueue: API.OperationMethod<PeekQueueInput, PeekQueueOutput, PeekQueueError, CelldOpContext>;
+export type PurgeQueueError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Reserved Queue operator request with JSON op=purge. This is not the private Queue RPC or settlement endpoint. */
+export declare const purgeQueue: API.OperationMethod<PurgeQueueInput, PurgeQueueOutput, PurgeQueueError, CelldOpContext>;
+export type PutKvError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Write an inline JSON byte array. Expiration is resolved by the cell clock. */
+export declare const putKv: API.OperationMethod<PutKvInput, PutKvOutput, PutKvError, CelldOpContext>;
+export type PutKvBase64Error = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Write base64-encoded bytes using the distinct put-base64 wire operation. */
+export declare const putKvBase64: API.OperationMethod<PutKvBase64Input, PutKvBase64Output, PutKvBase64Error, CelldOpContext>;
+export type RedriveQueueError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Reserved Queue operator request with JSON op=redrive. This is not the private Queue RPC or settlement endpoint. */
+export declare const redriveQueue: API.OperationMethod<RedriveQueueInput, RedriveQueueOutput, RedriveQueueError, CelldOpContext>;
+export type ResumeQueueError = PeerIncompatibleVersion | PeerWrongTarget | PeerReplayRejected | CelldOpError;
+/** Reserved Queue operator request with JSON op=resume. This is not the private Queue RPC or settlement endpoint. */
+export declare const resumeQueue: API.OperationMethod<ResumeQueueInput, ResumeQueueOutput, ResumeQueueError, CelldOpContext>;
+//# sourceMappingURL=runtime.d.ts.map