@apibara/protocol 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/shared/protocol.4b1cfe2c.d.cts

@@ -0,0 +1,756 @@
+import { Schema } from '@effect/schema';
+import { DefaultCallOptions, NormalizedServiceDefinition, ChannelCredentials, ChannelOptions } from 'nice-grpc';
+import { CallContext, CallOptions } from 'nice-grpc-common';
+import _m0 from 'protobufjs/minimal.js';
+import * as _effect_schema_AST from '@effect/schema/AST';
+
+/**
+ * A Duration represents a signed, fixed-length span of time represented
+ * as a count of seconds and fractions of seconds at nanosecond
+ * resolution. It is independent of any calendar and concepts like "day"
+ * or "month". It is related to Timestamp in that the difference between
+ * two Timestamp values is a Duration and it can be added or subtracted
+ * from a Timestamp. Range is approximately +-10,000 years.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Duration from two Timestamps in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Timestamp end = ...;
+ *     Duration duration = ...;
+ *
+ *     duration.seconds = end.seconds - start.seconds;
+ *     duration.nanos = end.nanos - start.nanos;
+ *
+ *     if (duration.seconds < 0 && duration.nanos > 0) {
+ *       duration.seconds += 1;
+ *       duration.nanos -= 1000000000;
+ *     } else if (duration.seconds > 0 && duration.nanos < 0) {
+ *       duration.seconds -= 1;
+ *       duration.nanos += 1000000000;
+ *     }
+ *
+ * Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+ *
+ *     Timestamp start = ...;
+ *     Duration duration = ...;
+ *     Timestamp end = ...;
+ *
+ *     end.seconds = start.seconds + duration.seconds;
+ *     end.nanos = start.nanos + duration.nanos;
+ *
+ *     if (end.nanos < 0) {
+ *       end.seconds -= 1;
+ *       end.nanos += 1000000000;
+ *     } else if (end.nanos >= 1000000000) {
+ *       end.seconds += 1;
+ *       end.nanos -= 1000000000;
+ *     }
+ *
+ * Example 3: Compute Duration from datetime.timedelta in Python.
+ *
+ *     td = datetime.timedelta(days=3, minutes=10)
+ *     duration = Duration()
+ *     duration.FromTimedelta(td)
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Duration type is encoded as a string rather than an
+ * object, where the string ends in the suffix "s" (indicating seconds) and
+ * is preceded by the number of seconds, with nanoseconds expressed as
+ * fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+ * encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+ * be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+ * microsecond should be expressed in JSON format as "3.000001s".
+ */
+interface Duration$1 {
+    /**
+     * Signed seconds of the span of time. Must be from -315,576,000,000
+     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+     */
+    readonly seconds: bigint;
+    /**
+     * Signed fractions of a second at nanosecond resolution of the span
+     * of time. Durations less than one second are represented with a 0
+     * `seconds` field and a positive or negative `nanos` field. For durations
+     * of one second or more, a non-zero value for the `nanos` field must be
+     * of the same sign as the `seconds` field. Must be from -999,999,999
+     * to +999,999,999 inclusive.
+     */
+    readonly nanos: number;
+}
+declare const Duration$1: {
+    encode(message: Duration$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Duration$1;
+    fromJSON(object: any): Duration$1;
+    toJSON(message: Duration$1): unknown;
+    create(base?: DeepPartial$1<Duration$1>): Duration$1;
+    fromPartial(object: DeepPartial$1<Duration$1>): Duration$1;
+};
+type Builtin$1 = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$1<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$1<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial$1<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial$1<T[K]>;
+} : Partial<T>;
+
+declare const protobufPackage = "dna.v2.stream";
+/** Apibara DNA server V2 */
+/** Data finality. */
+declare enum DataFinality$1 {
+    UNKNOWN = 0,
+    /** PENDING - Data was received, but is not part of the canonical chain yet. */
+    PENDING = 1,
+    /** ACCEPTED - Data is now part of the canonical chain, but could still be invalidated. */
+    ACCEPTED = 2,
+    /** FINALIZED - Data is finalized and cannot be invalidated. */
+    FINALIZED = 3,
+    UNRECOGNIZED = -1
+}
+declare function dataFinalityFromJSON(object: any): DataFinality$1;
+declare function dataFinalityToJSON(object: DataFinality$1): string;
+/** Data production mode. */
+declare enum DataProduction$1 {
+    UNKNOWN = 0,
+    /** BACKFILL - Data is for a backfilled block. */
+    BACKFILL = 1,
+    /** LIVE - Data is for a live block. */
+    LIVE = 2,
+    UNRECOGNIZED = -1
+}
+declare function dataProductionFromJSON(object: any): DataProduction$1;
+declare function dataProductionToJSON(object: DataProduction$1): string;
+/** A cursor over the stream content. */
+interface Cursor$1 {
+    /**
+     * Key used for ordering messages in the stream.
+     *
+     * This is usually the block or slot number.
+     */
+    readonly orderKey: bigint;
+    /**
+     * Key used to discriminate branches in the stream.
+     *
+     * This is usually the hash of the block.
+     */
+    readonly uniqueKey: Uint8Array;
+}
+declare const Cursor$1: {
+    encode(message: Cursor$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Cursor$1;
+    fromJSON(object: any): Cursor$1;
+    toJSON(message: Cursor$1): unknown;
+    create(base?: DeepPartial<Cursor$1>): Cursor$1;
+    fromPartial(object: DeepPartial<Cursor$1>): Cursor$1;
+};
+/** Request for the `Status` method. */
+interface StatusRequest$1 {
+}
+declare const StatusRequest$1: {
+    encode(_: StatusRequest$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StatusRequest$1;
+    fromJSON(_: any): StatusRequest$1;
+    toJSON(_: StatusRequest$1): unknown;
+    create(base?: DeepPartial<StatusRequest$1>): StatusRequest$1;
+    fromPartial(_: DeepPartial<StatusRequest$1>): StatusRequest$1;
+};
+/** Response for the `Status` method. */
+interface StatusResponse$1 {
+    /** The current head of the chain. */
+    readonly currentHead?: Cursor$1 | undefined;
+    /** The last cursor that was ingested by the node. */
+    readonly lastIngested?: Cursor$1 | undefined;
+    /** The finalized block. */
+    readonly finalized?: Cursor$1 | undefined;
+    /** The first block available. */
+    readonly starting?: Cursor$1 | undefined;
+}
+declare const StatusResponse$1: {
+    encode(message: StatusResponse$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StatusResponse$1;
+    fromJSON(object: any): StatusResponse$1;
+    toJSON(message: StatusResponse$1): unknown;
+    create(base?: DeepPartial<StatusResponse$1>): StatusResponse$1;
+    fromPartial(object: DeepPartial<StatusResponse$1>): StatusResponse$1;
+};
+/** Request data to be streamed. */
+interface StreamDataRequest$1 {
+    /**
+     * Cursor to start streaming from.
+     *
+     * If not specified, starts from the genesis block.
+     * Use the data's message `end_cursor` field to resume streaming.
+     */
+    readonly startingCursor?: Cursor$1 | undefined;
+    /**
+     * Return data with the specified finality.
+     *
+     * If not specified, defaults to `DATA_FINALITY_ACCEPTED`.
+     */
+    readonly finality?: DataFinality$1 | undefined;
+    /** Filters used to generate data. */
+    readonly filter: readonly Uint8Array[];
+    /**
+     * Heartbeat interval.
+     *
+     * Value must be between 10 and 60 seconds.
+     * If not specified, defaults to 30 seconds.
+     */
+    readonly heartbeatInterval?: Duration$1 | undefined;
+}
+declare const StreamDataRequest$1: {
+    encode(message: StreamDataRequest$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StreamDataRequest$1;
+    fromJSON(object: any): StreamDataRequest$1;
+    toJSON(message: StreamDataRequest$1): unknown;
+    create(base?: DeepPartial<StreamDataRequest$1>): StreamDataRequest$1;
+    fromPartial(object: DeepPartial<StreamDataRequest$1>): StreamDataRequest$1;
+};
+/** Contains a piece of streamed data. */
+interface StreamDataResponse$1 {
+    readonly message?: {
+        readonly $case: "data";
+        readonly data: Data$1;
+    } | {
+        readonly $case: "invalidate";
+        readonly invalidate: Invalidate$1;
+    } | {
+        readonly $case: "finalize";
+        readonly finalize: Finalize$1;
+    } | {
+        readonly $case: "heartbeat";
+        readonly heartbeat: Heartbeat$1;
+    } | {
+        readonly $case: "systemMessage";
+        readonly systemMessage: SystemMessage$1;
+    } | undefined;
+}
+declare const StreamDataResponse$1: {
+    encode(message: StreamDataResponse$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StreamDataResponse$1;
+    fromJSON(object: any): StreamDataResponse$1;
+    toJSON(message: StreamDataResponse$1): unknown;
+    create(base?: DeepPartial<StreamDataResponse$1>): StreamDataResponse$1;
+    fromPartial(object: DeepPartial<StreamDataResponse$1>): StreamDataResponse$1;
+};
+/** Invalidate data after the given cursor. */
+interface Invalidate$1 {
+    /**
+     * The cursor of the new chain's head.
+     *
+     * All data after this cursor should be considered invalid.
+     */
+    readonly cursor?: Cursor$1 | undefined;
+    /** List of blocks that were removed from the chain. */
+    readonly removed: readonly Cursor$1[];
+}
+declare const Invalidate$1: {
+    encode(message: Invalidate$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Invalidate$1;
+    fromJSON(object: any): Invalidate$1;
+    toJSON(message: Invalidate$1): unknown;
+    create(base?: DeepPartial<Invalidate$1>): Invalidate$1;
+    fromPartial(object: DeepPartial<Invalidate$1>): Invalidate$1;
+};
+/** Move the finalized block forward. */
+interface Finalize$1 {
+    /**
+     * The cursor of the new finalized block.
+     *
+     * All data before this cursor cannot be invalidated.
+     */
+    readonly cursor?: Cursor$1 | undefined;
+}
+declare const Finalize$1: {
+    encode(message: Finalize$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Finalize$1;
+    fromJSON(object: any): Finalize$1;
+    toJSON(message: Finalize$1): unknown;
+    create(base?: DeepPartial<Finalize$1>): Finalize$1;
+    fromPartial(object: DeepPartial<Finalize$1>): Finalize$1;
+};
+/**
+ * A single block of data.
+ *
+ * If the request specified multiple filters, the `data` field will contain the
+ * data for each filter in the same order as the filters were specified in the
+ * request.
+ * If no data is available for a filter, the corresponding data field will be
+ * empty.
+ */
+interface Data$1 {
+    /** Cursor that generated this block of data. */
+    readonly cursor?: Cursor$1 | undefined;
+    /** Block cursor. Use this cursor to resume the stream. */
+    readonly endCursor?: Cursor$1 | undefined;
+    /** The finality status of the block. */
+    readonly finality: DataFinality$1;
+    /**
+     * The block data.
+     *
+     * This message contains chain-specific data serialized using protobuf.
+     */
+    readonly data: readonly Uint8Array[];
+    /** The production mode of the block. */
+    readonly production: DataProduction$1;
+}
+declare const Data$1: {
+    encode(message: Data$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Data$1;
+    fromJSON(object: any): Data$1;
+    toJSON(message: Data$1): unknown;
+    create(base?: DeepPartial<Data$1>): Data$1;
+    fromPartial(object: DeepPartial<Data$1>): Data$1;
+};
+/** Sent to clients to check if stream is still connected. */
+interface Heartbeat$1 {
+}
+declare const Heartbeat$1: {
+    encode(_: Heartbeat$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Heartbeat$1;
+    fromJSON(_: any): Heartbeat$1;
+    toJSON(_: Heartbeat$1): unknown;
+    create(base?: DeepPartial<Heartbeat$1>): Heartbeat$1;
+    fromPartial(_: DeepPartial<Heartbeat$1>): Heartbeat$1;
+};
+/** Message from the server to the client. */
+interface SystemMessage$1 {
+    readonly output?: {
+        readonly $case: "stdout";
+        readonly stdout: string;
+    } | {
+        readonly $case: "stderr";
+        readonly stderr: string;
+    } | undefined;
+}
+declare const SystemMessage$1: {
+    encode(message: SystemMessage$1, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SystemMessage$1;
+    fromJSON(object: any): SystemMessage$1;
+    toJSON(message: SystemMessage$1): unknown;
+    create(base?: DeepPartial<SystemMessage$1>): SystemMessage$1;
+    fromPartial(object: DeepPartial<SystemMessage$1>): SystemMessage$1;
+};
+type DnaStreamDefinition = typeof DnaStreamDefinition;
+declare const DnaStreamDefinition: {
+    readonly name: "DnaStream";
+    readonly fullName: "dna.v2.stream.DnaStream";
+    readonly methods: {
+        /** Stream data from the server. */
+        readonly streamData: {
+            readonly name: "StreamData";
+            readonly requestType: {
+                encode(message: StreamDataRequest$1, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StreamDataRequest$1;
+                fromJSON(object: any): StreamDataRequest$1;
+                toJSON(message: StreamDataRequest$1): unknown;
+                create(base?: DeepPartial<StreamDataRequest$1>): StreamDataRequest$1;
+                fromPartial(object: DeepPartial<StreamDataRequest$1>): StreamDataRequest$1;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: StreamDataResponse$1, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StreamDataResponse$1;
+                fromJSON(object: any): StreamDataResponse$1;
+                toJSON(message: StreamDataResponse$1): unknown;
+                create(base?: DeepPartial<StreamDataResponse$1>): StreamDataResponse$1;
+                fromPartial(object: DeepPartial<StreamDataResponse$1>): StreamDataResponse$1;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Get DNA server status. */
+        readonly status: {
+            readonly name: "Status";
+            readonly requestType: {
+                encode(_: StatusRequest$1, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StatusRequest$1;
+                fromJSON(_: any): StatusRequest$1;
+                toJSON(_: StatusRequest$1): unknown;
+                create(base?: DeepPartial<StatusRequest$1>): StatusRequest$1;
+                fromPartial(_: DeepPartial<StatusRequest$1>): StatusRequest$1;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: StatusResponse$1, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StatusResponse$1;
+                fromJSON(object: any): StatusResponse$1;
+                toJSON(message: StatusResponse$1): unknown;
+                create(base?: DeepPartial<StatusResponse$1>): StatusResponse$1;
+                fromPartial(object: DeepPartial<StatusResponse$1>): StatusResponse$1;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+interface DnaStreamServiceImplementation<CallContextExt = {}> {
+    /** Stream data from the server. */
+    streamData(request: StreamDataRequest$1, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<StreamDataResponse$1>>;
+    /** Get DNA server status. */
+    status(request: StatusRequest$1, context: CallContext & CallContextExt): Promise<DeepPartial<StatusResponse$1>>;
+}
+interface DnaStreamClient<CallOptionsExt = {}> {
+    /** Stream data from the server. */
+    streamData(request: DeepPartial<StreamDataRequest$1>, options?: CallOptions & CallOptionsExt): AsyncIterable<StreamDataResponse$1>;
+    /** Get DNA server status. */
+    status(request: DeepPartial<StatusRequest$1>, options?: CallOptions & CallOptionsExt): Promise<StatusResponse$1>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    readonly $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    readonly $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type ServerStreamingMethodResult<Response> = {
+    [Symbol.asyncIterator](): AsyncIterator<Response, void>;
+};
+
+type stream_DeepPartial<T> = DeepPartial<T>;
+type stream_DnaStreamClient<CallOptionsExt = {}> = DnaStreamClient<CallOptionsExt>;
+declare const stream_DnaStreamDefinition: typeof DnaStreamDefinition;
+type stream_DnaStreamServiceImplementation<CallContextExt = {}> = DnaStreamServiceImplementation<CallContextExt>;
+type stream_ServerStreamingMethodResult<Response> = ServerStreamingMethodResult<Response>;
+declare const stream_dataFinalityFromJSON: typeof dataFinalityFromJSON;
+declare const stream_dataFinalityToJSON: typeof dataFinalityToJSON;
+declare const stream_dataProductionFromJSON: typeof dataProductionFromJSON;
+declare const stream_dataProductionToJSON: typeof dataProductionToJSON;
+declare const stream_protobufPackage: typeof protobufPackage;
+declare namespace stream {
+  export { Cursor$1 as Cursor, Data$1 as Data, DataFinality$1 as DataFinality, DataProduction$1 as DataProduction, type stream_DeepPartial as DeepPartial, type stream_DnaStreamClient as DnaStreamClient, stream_DnaStreamDefinition as DnaStreamDefinition, type stream_DnaStreamServiceImplementation as DnaStreamServiceImplementation, Finalize$1 as Finalize, Heartbeat$1 as Heartbeat, Invalidate$1 as Invalidate, type stream_ServerStreamingMethodResult as ServerStreamingMethodResult, StatusRequest$1 as StatusRequest, StatusResponse$1 as StatusResponse, StreamDataRequest$1 as StreamDataRequest, StreamDataResponse$1 as StreamDataResponse, SystemMessage$1 as SystemMessage, stream_dataFinalityFromJSON as dataFinalityFromJSON, stream_dataFinalityToJSON as dataFinalityToJSON, stream_dataProductionFromJSON as dataProductionFromJSON, stream_dataProductionToJSON as dataProductionToJSON, stream_protobufPackage as protobufPackage };
+}
+
+/** Bytes encoded as a 0x-prefixed hex string. */
+declare const Bytes: Schema.SchemaClass<`0x${string}`, `0x${string}`, never>;
+type Bytes = typeof Bytes.Type;
+declare const BytesFromUint8Array: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
+/** Represent a position in the stream. */
+declare const _Cursor: Schema.Struct<{
+    /** The block number. */
+    orderKey: typeof Schema.BigIntFromSelf;
+    /** The block hash, if any. */
+    uniqueKey: Schema.PropertySignature<"?:", `0x${string}`, never, ":", Uint8Array, false, never>;
+}>;
+/** The Cursor protobuf representation. */
+interface CursorProto extends Schema.Schema.Encoded<typeof _Cursor> {
+}
+interface Cursor extends Schema.Schema.Type<typeof _Cursor> {
+}
+declare const Cursor: Schema.Schema<Cursor, CursorProto>;
+declare const createCursor: (props: Cursor) => Cursor;
+declare const cursorToProto: (a: Cursor, overrideOptions?: _effect_schema_AST.ParseOptions) => CursorProto;
+declare const cursorFromProto: (i: CursorProto, overrideOptions?: _effect_schema_AST.ParseOptions) => Cursor;
+declare const CursorFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Schema<Cursor, CursorProto, never>>;
+declare const cursorToBytes: (a: Cursor, overrideOptions?: _effect_schema_AST.ParseOptions) => Uint8Array;
+declare const cursorFromBytes: (i: Uint8Array, overrideOptions?: _effect_schema_AST.ParseOptions) => Cursor;
+declare function isCursor(value: unknown): value is Cursor;
+/** Normalize a cursor.
+ *
+ * The challenge is that the `Cursor` validator expects `uniqueKey` to be either a `0x${string}`
+ * or not present at all. Setting the field to `undefined` will result in a validation error.
+ *
+ * @param cursor The cursor to normalize
+ */
+declare function normalizeCursor(cursor: {
+    orderKey: bigint;
+    uniqueKey: string | null;
+}): Cursor;
+
+/** The request to the `status` endpoint. */
+declare const StatusRequest: Schema.Struct<{}>;
+type StatusRequest = typeof StatusRequest.Type;
+declare const statusRequestToProto: (a: {}, overrideOptions?: _effect_schema_AST.ParseOptions) => {};
+declare const statusRequestFromProto: (i: {}, overrideOptions?: _effect_schema_AST.ParseOptions) => {};
+/** The response from the `status` endpoint. */
+declare const StatusResponse: Schema.Struct<{
+    currentHead: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    lastIngested: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    finalized: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    starting: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+}>;
+type StatusResponse = typeof StatusResponse.Type;
+declare const statusResponseToProto: (a: {
+    readonly currentHead?: Cursor | undefined;
+    readonly lastIngested?: Cursor | undefined;
+    readonly finalized?: Cursor | undefined;
+    readonly starting?: Cursor | undefined;
+}, overrideOptions?: _effect_schema_AST.ParseOptions) => {
+    readonly currentHead?: CursorProto | undefined;
+    readonly lastIngested?: CursorProto | undefined;
+    readonly finalized?: CursorProto | undefined;
+    readonly starting?: CursorProto | undefined;
+};
+declare const statusResponseFromProto: (i: {
+    readonly currentHead?: CursorProto | undefined;
+    readonly lastIngested?: CursorProto | undefined;
+    readonly finalized?: CursorProto | undefined;
+    readonly starting?: CursorProto | undefined;
+}, overrideOptions?: _effect_schema_AST.ParseOptions) => {
+    readonly currentHead?: Cursor | undefined;
+    readonly lastIngested?: Cursor | undefined;
+    readonly finalized?: Cursor | undefined;
+    readonly starting?: Cursor | undefined;
+};
+
+/** Data finality. */
+declare const DataFinality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+type DataFinality = typeof DataFinality.Type;
+/** Data production mode. */
+declare const DataProduction: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
+type DataProduction = typeof DataProduction.Type;
+declare const Duration: Schema.Struct<{
+    seconds: typeof Schema.BigIntFromSelf;
+    nanos: typeof Schema.Number;
+}>;
+/** Create a `StreamDataRequest` with the given filter schema. */
+declare const StreamDataRequest: <TA, TR>(filter: Schema.Schema<TA, Uint8Array, TR>) => Schema.Struct<{
+    finality: Schema.optional<Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>>;
+    startingCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    filter: Schema.mutable<Schema.Array$<Schema.Schema<TA, Uint8Array, TR>>>;
+    heartbeatInterval: Schema.optional<Schema.Struct<{
+        seconds: typeof Schema.BigIntFromSelf;
+        nanos: typeof Schema.Number;
+    }>>;
+}>;
+type StreamDataRequest<TA> = {
+    finality?: DataFinality | undefined;
+    startingCursor?: Cursor | undefined;
+    filter: TA[];
+};
+declare const Invalidate: Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>;
+type Invalidate = typeof Invalidate.Type;
+declare const Finalize: Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>;
+type Finalize = typeof Finalize.Type;
+declare const Heartbeat: Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>;
+type Heartbeat = typeof Heartbeat.Type;
+declare const StdOut: Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+    stdout: typeof Schema.String;
+}>;
+type StdOut = typeof StdOut.Type;
+declare const StdErr: Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+    stderr: typeof Schema.String;
+}>;
+type StdErr = typeof StdErr.Type;
+declare const SystemMessage: Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: Schema.Struct<{
+        output: Schema.Union<[Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+            stdout: typeof Schema.String;
+        }>, Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+            stderr: typeof Schema.String;
+        }>]>;
+    }>;
+}>;
+type SystemMessage = typeof SystemMessage.Type;
+declare const Data: <TA, TR>(schema: Schema.Schema<TA | null, Uint8Array, TR>) => Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
+    data: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: Schema.Schema<Cursor, CursorProto, never>;
+        finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
+        data: Schema.Array$<Schema.Schema<TA | null, Uint8Array, TR>>;
+    }>;
+}>;
+declare const ResponseWithoutData: Schema.Union<[Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: Schema.Struct<{
+        output: Schema.Union<[Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+            stdout: typeof Schema.String;
+        }>, Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+            stderr: typeof Schema.String;
+        }>]>;
+    }>;
+}>]>;
+type ResponseWithoutData = typeof ResponseWithoutData.Type;
+declare const StreamDataResponse: <TA, TR>(data: Schema.Schema<TA | null, Uint8Array, TR>) => Schema.Union<[Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
+    data: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: Schema.Schema<Cursor, CursorProto, never>;
+        finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
+        data: Schema.Array$<Schema.Schema<TA | null, Uint8Array, TR>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: Schema.Struct<{
+        output: Schema.Union<[Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+            stdout: typeof Schema.String;
+        }>, Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+            stderr: typeof Schema.String;
+        }>]>;
+    }>;
+}>]>;
+type StreamDataResponse<TA> = ResponseWithoutData | {
+    _tag: "data";
+    data: {
+        cursor?: Cursor | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data: readonly (TA | null)[];
+    };
+};
+
+/** Configure a DNA stream. */
+declare class StreamConfig<TFilter, TBlock> {
+    private filter;
+    private block;
+    mergeFilter: (a: TFilter, b: TFilter) => TFilter;
+    private request;
+    private response;
+    constructor(filter: Schema.Schema<TFilter, Uint8Array, never>, block: Schema.Schema<TBlock | null, Uint8Array, never>, mergeFilter: (a: TFilter, b: TFilter) => TFilter);
+    /** Filter schema. */
+    get Filter(): Schema.Schema<TFilter, Uint8Array, never>;
+    /** Block schema. */
+    get Block(): Schema.Schema<TBlock | null, Uint8Array, never>;
+    /** Stream data request schema. */
+    get Request(): Schema.Struct<{
+        finality: Schema.optional<Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>>;
+        startingCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        filter: Schema.mutable<Schema.Array$<Schema.Schema<TFilter, Uint8Array, never>>>;
+        heartbeatInterval: Schema.optional<Schema.Struct<{
+            seconds: typeof Schema.BigIntFromSelf;
+            nanos: typeof Schema.Number;
+        }>>;
+    }>;
+    /** Stream data response schema. */
+    get Response(): Schema.Union<[Schema.Struct<{
+        _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
+        data: Schema.Struct<{
+            cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+            endCursor: Schema.Schema<Cursor, CursorProto, never>;
+            finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+            production: Schema.transform<Schema.Enums<typeof DataProduction$1>, Schema.Literal<["backfill", "live", "unknown"]>>;
+            data: Schema.Array$<Schema.Schema<TBlock | null, Uint8Array, never>>;
+        }>;
+    }>, Schema.Struct<{
+        _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+        invalidate: Schema.Struct<{
+            cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        }>;
+    }>, Schema.Struct<{
+        _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+        finalize: Schema.Struct<{
+            cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        }>;
+    }>, Schema.Struct<{
+        _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+    }>, Schema.Struct<{
+        _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+        systemMessage: Schema.Struct<{
+            output: Schema.Union<[Schema.Struct<{
+                _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+                stdout: typeof Schema.String;
+            }>, Schema.Struct<{
+                _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+                stderr: typeof Schema.String;
+            }>]>;
+        }>;
+    }>]>;
+}
+
+declare class TimeoutError extends Error {
+    constructor(timeout: number);
+}
+/** Client call options. */
+interface ClientCallOptions {
+    signal?: AbortSignal;
+}
+interface StreamDataOptions extends ClientCallOptions {
+    /** Stop at the specified cursor (inclusive). */
+    endingCursor?: Cursor;
+    /** Timeout between messages, in milliseconds. */
+    timeout?: number;
+}
+/** DNA client. */
+interface Client<TFilter, TBlock> {
+    /** Fetch the DNA stream status. */
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    /** Start streaming data from the DNA server. */
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): AsyncIterable<StreamDataResponse<TBlock>>;
+}
+type CreateClientOptions = {
+    defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<DnaStreamDefinition>>;
+    credentials?: ChannelCredentials;
+    channelOptions?: ChannelOptions;
+};
+/** Create a client connecting to the DNA grpc service. */
+declare function createClient<TFilter, TBlock>(config: StreamConfig<TFilter, TBlock>, streamUrl: string, options?: CreateClientOptions): GrpcClient<TFilter, TBlock>;
+declare class GrpcClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private config;
+    private client;
+    private encodeRequest;
+    constructor(config: StreamConfig<TFilter, TBlock>, client: DnaStreamClient);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<{
+        readonly currentHead?: Cursor | undefined;
+        readonly lastIngested?: Cursor | undefined;
+        readonly finalized?: Cursor | undefined;
+        readonly starting?: Cursor | undefined;
+    }>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private it;
+    private schema;
+    private options?;
+    constructor(it: AsyncIterable<StreamDataResponse$1>, schema: Schema.Schema<TBlock | null, Uint8Array, never>, options?: StreamDataOptions | undefined);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+export { StreamConfig as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type ClientCallOptions as E, Finalize as F, type StreamDataOptions as G, Heartbeat as H, Invalidate as I, type Client as J, type CreateClientOptions as K, createClient as L, GrpcClient as M, StreamDataIterable as N, DataFinality$1 as O, DataProduction$1 as P, StatusRequest as S, TimeoutError as T, _Cursor as _, DnaStreamDefinition as a, BytesFromUint8Array as b, Cursor as c, createCursor as d, cursorToProto as e, cursorFromProto as f, CursorFromBytes as g, cursorToBytes as h, cursorFromBytes as i, isCursor as j, statusRequestToProto as k, statusRequestFromProto as l, StatusResponse as m, normalizeCursor as n, statusResponseToProto as o, statusResponseFromProto as p, DataFinality as q, DataProduction as r, stream as s, Duration as t, StreamDataRequest as u, StdOut as v, StdErr as w, SystemMessage as x, Data as y, StreamDataResponse as z };