@smart-byte/leani-sdk 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/openapi.generated.d.ts

@@ -964,13 +964,48 @@ export interface paths {
         get: operations["getBackfillSubscription"];
         put?: never;
         post?: never;
-        /** Delete a terminal backfill subscription */
+        /**
+         * Delete a terminal backfill subscription
+         * @description A completed subscription can be deleted once its consumer acknowledged
+         *     the completion. A failed or cancelled one can be deleted once its
+         *     required consumer acknowledged every delivered record, and gets 409
+         *     `backfill_conflict` while one is unacknowledged: read its stream to
+         *     the end and acknowledge, or pass `discardUnacknowledged=true`.
+         */
         delete: operations["deleteBackfillSubscription"];
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
+    "/admin/v1/backfill-subscriptions/{id}/retry": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: components["parameters"]["Identifier"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Retry a failed backfill subscription
+         * @description Re-queues a failed subscription. It resumes from its committed
+         *     progress with the same history stream, consumer, and acknowledgement,
+         *     and its error is cleared. A subscription that is still active returns
+         *     its status unchanged; a completed or cancelled one gets 409
+         *     `backfill_conflict`. A failed subscription whose processor instance is
+         *     not configured (see `processorConfigured`) gets 400 `invalid_request`
+         *     and stays failed.
+         */
+        post: operations["retryBackfillSubscription"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/admin/v1/backfill-subscriptions/{id}/cancel": {
         parameters: {
             query?: never;
@@ -982,7 +1017,12 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Cancel a backfill subscription */
+        /**
+         * Cancel a backfill subscription
+         * @description A draining subscription, whose job finished but whose required
+         *     consumer has not acknowledged the completion, becomes `cancelled`,
+         *     even when its processor instance is not configured.
+         */
         post: operations["cancelBackfillSubscription"];
         delete?: never;
         options?: never;
@@ -1484,7 +1524,10 @@ export interface components {
             complete: boolean;
             /**
              * @description `paused` and `failed` report the processor's live lane;
-             *     `/v1/network/status` gives its `pauseReason`.
+             *     `/v1/network/status` gives its `pauseReason`. `catching_up`
+             *     means the range has no gaps but the processor has not reached
+             *     `chainFinalizedHead` or the node is not ready; only then is it
+             *     `live`.
              * @enum {string}
              */
             state: "starting" | "backfilling" | "catching_up" | "live" | "degraded" | "paused" | "failed";
@@ -1618,6 +1661,67 @@ export interface components {
             createdAtUnixMs: components["schemas"]["DecimalQuantity"];
             updatedAtUnixMs: components["schemas"]["DecimalQuantity"];
         };
+        /** @description A backfill subscription or materialization job. */
+        BackfillStatus: {
+            /**
+             * @description Opaque; do not parse it. An application finds its own
+             *     subscriptions by `consumer`.
+             */
+            id: string;
+            /** @enum {string} */
+            owner: "subscription" | "materialization";
+            /** @description The processor instance that runs the job. */
+            processor: string;
+            /**
+             * @description Whether the node configures the processor instance `processor`
+             *     now: exactly that instance, not another instance of its kind.
+             *     Without it, the subscription's stream and acknowledgement routes
+             *     refuse the subscription. That can be temporary, as when a
+             *     restart's configuration leaves the instance out by mistake. If
+             *     the instance will not return, cancel the subscription and delete
+             *     it with `discardUnacknowledged=true`, which discards its
+             *     unacknowledged records.
+             */
+            processorConfigured: boolean;
+            /**
+             * @description The subscription's required consumer, which reads and
+             *     acknowledges its history stream; null for a materialization job.
+             */
+            consumer: string | null;
+            /** @description The subscription's history stream. */
+            deliveryStreamId?: string;
+            publicationRevision?: components["schemas"]["DecimalQuantity"];
+            fromBlock: components["schemas"]["SafeInteger"];
+            toBlock: components["schemas"]["SafeInteger"];
+            ranges: components["schemas"]["RequestedRange"][];
+            requestedBlocks: components["schemas"]["SafeInteger"];
+            processedBlocks: components["schemas"]["SafeInteger"];
+            remainingBlocks: components["schemas"]["SafeInteger"];
+            capturedFinalizedTarget?: components["schemas"]["SafeInteger"];
+            /** @enum {string} */
+            mode: "fill_missing" | "recompute";
+            /** @description The subscription's effective history batch limits. */
+            batching?: {
+                targetEncodedBytes: components["schemas"]["SafeInteger"];
+                maximumEncodedBytes: components["schemas"]["SafeInteger"];
+                maximumEvents: components["schemas"]["SafeInteger"];
+                maximumProcessedBlocks: components["schemas"]["SafeInteger"];
+                maximumDelayMs: components["schemas"]["SafeInteger"];
+                maximumBufferedBatches: components["schemas"]["SafeInteger"];
+                maximumBufferedBytes: components["schemas"]["SafeInteger"];
+                /** @enum {string} */
+                compression: "none" | "gzip";
+            };
+            /** @enum {string} */
+            state: "waiting_for_consumer" | "queued" | "running" | "backpressured" | "storage_backpressured" | "draining" | "complete_reclaimable" | "completed" | "failed" | "cancelled";
+            attempts: components["schemas"]["SafeInteger"];
+            updatedAtUnixMs: components["schemas"]["SafeInteger"];
+            /** @description The completed job's source report; null until it completes. */
+            report: {
+                [key: string]: unknown;
+            } | null;
+            lastError: string | null;
+        };
         RecoveryCheckpoint: {
             checkpointId: components["schemas"]["SafeInteger"];
             processorInstance: string;
@@ -1784,12 +1888,79 @@ export interface components {
             /** @description Versioned processor change schema identifier. */
             schema: string;
             key: string | null;
+            /**
+             * @description The processor's entity for `apply` and `undo`. For `finalized`,
+             *     the `system.finality.put` kind carries `{ throughBlock }`, and the
+             *     `system.live_gap.put` kind carries
+             *     `{ fromBlock, toBlock, reason: "not_filled" }`: blocks the live
+             *     lane skipped and did not fill, such as after a restart at a later
+             *     finalized anchor. A processor with `live_gap_fill` delivers a
+             *     short range itself as `live_recovery` batches; request what is
+             *     announced as history.
+             */
             data: unknown;
             /** @description Present only on reset_required events. */
             coverage?: components["schemas"]["ProcessorCoverage"];
             /** @description Stable emission timestamp. */
             emittedAt: string;
         };
+        LiveStreamRecord: components["schemas"]["LiveStreamHello"] | components["schemas"]["LiveStreamBatch"] | components["schemas"]["StreamHeartbeat"] | components["schemas"]["StreamFailure"];
+        LiveStreamHello: {
+            /** @constant */
+            type: "hello";
+            /** @constant */
+            apiVersion: "1";
+            chainId: components["schemas"]["SafeInteger"];
+            processor: components["schemas"]["ProcessorSummary"];
+            streamId: string;
+            /** @constant */
+            streamKind: "live";
+            acknowledgedCursor: components["schemas"]["Cursor"];
+            storeEpoch: string;
+            heartbeatIntervalMs: components["schemas"]["DecimalQuantity"];
+            /** @description Send as `x-leani-consumer-session` to acknowledge, renew, or release. */
+            sessionToken: string;
+            sessionExpiresAtUnixMs: components["schemas"]["DecimalQuantity"];
+            leaseTtlMs: components["schemas"]["DecimalQuantity"];
+            /** @description What the processor covers as the session starts, to diff against the destination. */
+            coverage: components["schemas"]["ProcessorCoverage"];
+        };
+        LiveStreamBatch: {
+            /** @constant */
+            type: "batch";
+            streamId: string;
+            /** @enum {string} */
+            originKind: "live" | "live_recovery";
+            originId: string;
+            publicationRevision: components["schemas"]["DecimalQuantity"];
+            fromBlock: components["schemas"]["SafeInteger"];
+            throughBlock: components["schemas"]["SafeInteger"];
+            processedBlockCount: components["schemas"]["DecimalQuantity"];
+            /** @description Changes other than `system.*` kinds. */
+            domainChangeCount: components["schemas"]["DecimalQuantity"];
+            progressUnitCount: components["schemas"]["DecimalQuantity"];
+            rawPayloadBytes: components["schemas"]["DecimalQuantity"];
+            uncompressedEncodedBytes: components["schemas"]["DecimalQuantity"];
+            transmittedBytes: components["schemas"]["DecimalQuantity"];
+            buildDelayMs: components["schemas"]["DecimalQuantity"];
+            firstCursor: components["schemas"]["Cursor"];
+            lastCursor: components["schemas"]["Cursor"];
+            acknowledgeableCursor: components["schemas"]["Cursor"];
+            changes: components["schemas"]["ChangeEnvelope"][];
+        };
+        StreamHeartbeat: {
+            /** @constant */
+            type: "heartbeat";
+            emittedAt: string;
+        };
+        StreamFailure: {
+            /** @enum {string} */
+            type: "error" | "reset_required";
+            code: string;
+            message: string;
+            earliestAvailableSequence: components["schemas"]["DecimalQuantity"] | null;
+            latestAvailableSequence: components["schemas"]["DecimalQuantity"] | null;
+        };
         ChangeHead: {
             earliestSequence: components["schemas"]["DecimalQuantity"] | null;
             latestSequence: components["schemas"]["DecimalQuantity"] | null;
@@ -2864,12 +3035,21 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description Server-sent live-lane batches. */
+            /**
+             * @description Newline-delimited JSON records: first a `hello` with the
+             *     processor's coverage as the session starts, then whole-block
+             *     `batch` records and, while idle, `heartbeat` records. An `error`
+             *     or `reset_required` record ends the stream. A batch of a
+             *     `system.live_gap.put` change announces blocks the live lane
+             *     skipped and did not fill.
+             */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/x-ndjson": components["schemas"]["LiveStreamRecord"];
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3268,7 +3448,11 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["BackfillStatus"][];
+                    };
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3287,7 +3471,9 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3308,14 +3494,23 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
             };
             default: components["responses"]["Error"];
         };
     };
     deleteBackfillSubscription: {
         parameters: {
-            query?: never;
+            query?: {
+                /**
+                 * @description Delete a failed or cancelled subscription although its required
+                 *     consumer has not acknowledged every record. Has no effect on a
+                 *     subscription that is still running.
+                 */
+                discardUnacknowledged?: boolean;
+            };
             header?: {
                 /**
                  * @description Marks a mutating request without a JSON body as sent by a Leani
@@ -3341,6 +3536,36 @@ export interface operations {
             default: components["responses"]["Error"];
         };
     };
+    retryBackfillSubscription: {
+        parameters: {
+            query?: never;
+            header?: {
+                /**
+                 * @description Marks a mutating request without a JSON body as sent by a Leani
+                 *     client. A POST or DELETE needs `content-type: application/json` or
+                 *     this header, and gets HTTP 415 otherwise.
+                 */
+                "x-leani-request"?: components["parameters"]["LeaniRequest"];
+            };
+            path: {
+                id: components["parameters"]["Identifier"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Retried backfill subscription. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
+            };
+            default: components["responses"]["Error"];
+        };
+    };
     cancelBackfillSubscription: {
         parameters: {
             query?: never;
@@ -3364,7 +3589,9 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3383,7 +3610,11 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": {
+                        data: components["schemas"]["BackfillStatus"][];
+                    };
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3402,7 +3633,9 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3423,7 +3656,9 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
             };
             default: components["responses"]["Error"];
         };
@@ -3479,7 +3714,9 @@ export interface operations {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": components["schemas"]["BackfillStatus"];
+                };
             };
             default: components["responses"]["Error"];
         };