@apibara/protocol 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/shared/{protocol.e9aed6a3.d.ts → protocol.59e5839c.d.cts}

@@ -1,15 +1,133 @@
 import { Schema } from '@effect/schema';
-import { DefaultCallOptions, NormalizedServiceDefinition } from 'nice-grpc';
+import { DefaultCallOptions, NormalizedServiceDefinition, ChannelCredentials, ChannelOptions } from 'nice-grpc';
 import { CallContext, CallOptions } from 'nice-grpc-common';
-import _m0 from 'protobufjs/minimal';
+import _m0 from 'protobufjs/minimal.js';
 import * as _effect_schema_AST from '@effect/schema/AST';
 
-declare const protobufPackage$1 = "dna.v2.common";
+/**
+ * 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;
 /** A cursor over the stream content. */
 interface Cursor$1 {
-    /** Key used for ordering messages in the stream. */
+    /**
+     * 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. */
+    /**
+     * Key used to discriminate branches in the stream.
+     *
+     * This is usually the hash of the block.
+     */
     readonly uniqueKey: Uint8Array;
 }
 declare const Cursor$1: {
@@ -17,8 +135,8 @@ declare const Cursor$1: {
     decode(input: _m0.Reader | Uint8Array, length?: number): Cursor$1;
     fromJSON(object: any): Cursor$1;
     toJSON(message: Cursor$1): unknown;
-    create(base?: DeepPartial$1<Cursor$1>): Cursor$1;
-    fromPartial(object: DeepPartial$1<Cursor$1>): Cursor$1;
+    create(base?: DeepPartial<Cursor$1>): Cursor$1;
+    fromPartial(object: DeepPartial<Cursor$1>): Cursor$1;
 };
 /** Request for the `Status` method. */
 interface StatusRequest$1 {
@@ -28,8 +146,8 @@ declare const StatusRequest$1: {
     decode(input: _m0.Reader | Uint8Array, length?: number): StatusRequest$1;
     fromJSON(_: any): StatusRequest$1;
     toJSON(_: StatusRequest$1): unknown;
-    create(base?: DeepPartial$1<StatusRequest$1>): StatusRequest$1;
-    fromPartial(_: DeepPartial$1<StatusRequest$1>): StatusRequest$1;
+    create(base?: DeepPartial<StatusRequest$1>): StatusRequest$1;
+    fromPartial(_: DeepPartial<StatusRequest$1>): StatusRequest$1;
 };
 /** Response for the `Status` method. */
 interface StatusResponse$1 {
@@ -37,56 +155,43 @@ interface StatusResponse$1 {
     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$1<StatusResponse$1>): StatusResponse$1;
-    fromPartial(object: DeepPartial$1<StatusResponse$1>): StatusResponse$1;
+    create(base?: DeepPartial<StatusResponse$1>): StatusResponse$1;
+    fromPartial(object: DeepPartial<StatusResponse$1>): StatusResponse$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 namespace common {
-  export { Cursor$1 as Cursor, type DeepPartial$1 as DeepPartial, StatusRequest$1 as StatusRequest, StatusResponse$1 as StatusResponse, protobufPackage$1 as protobufPackage };
-}
-
-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;
 /** Request data to be streamed. */
 interface StreamDataRequest$1 {
-    /** Cursor to start streaming from. */
+    /**
+     * 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;
@@ -104,6 +209,9 @@ interface StreamDataResponse$1 {
     } | {
         readonly $case: "invalidate";
         readonly invalidate: Invalidate$1;
+    } | {
+        readonly $case: "finalize";
+        readonly finalize: Finalize$1;
     } | {
         readonly $case: "heartbeat";
         readonly heartbeat: Heartbeat$1;
@@ -122,8 +230,14 @@ declare const StreamDataResponse$1: {
 };
 /** Invalidate data after the given cursor. */
 interface Invalidate$1 {
-    /** The cursor of the message before the now invalid data. */
+    /**
+     * 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;
@@ -133,6 +247,23 @@ declare const Invalidate$1: {
     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.
  *
@@ -149,7 +280,11 @@ interface Data$1 {
     readonly endCursor?: Cursor$1 | undefined;
     /** The finality status of the block. */
     readonly finality: DataFinality$1;
-    /** The block data. */
+    /**
+     * The block data.
+     *
+     * This message contains chain-specific data serialized using protobuf.
+     */
     readonly data: readonly Uint8Array[];
 }
 declare const Data$1: {
@@ -222,38 +357,20 @@ declare const DnaStreamDefinition: {
             readonly name: "Status";
             readonly requestType: {
                 encode(_: StatusRequest$1, writer?: _m0.Writer): _m0.Writer;
-                decode(input: Uint8Array | _m0.Reader, length?: number | undefined): StatusRequest$1;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StatusRequest$1;
                 fromJSON(_: any): StatusRequest$1;
                 toJSON(_: StatusRequest$1): unknown;
-                create(base?: {} | undefined): StatusRequest$1;
-                fromPartial(_: {}): StatusRequest$1;
+                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: Uint8Array | _m0.Reader, length?: number | undefined): StatusResponse$1;
+                decode(input: _m0.Reader | Uint8Array, length?: number): StatusResponse$1;
                 fromJSON(object: any): StatusResponse$1;
                 toJSON(message: StatusResponse$1): unknown;
-                create(base?: {
-                    readonly currentHead?: {
-                        readonly orderKey?: bigint;
-                        readonly uniqueKey?: Uint8Array;
-                    } | undefined;
-                    readonly lastIngested?: {
-                        readonly orderKey?: bigint;
-                        readonly uniqueKey?: Uint8Array;
-                    } | undefined;
-                } | undefined): StatusResponse$1;
-                fromPartial(object: {
-                    readonly currentHead?: {
-                        readonly orderKey?: bigint;
-                        readonly uniqueKey?: Uint8Array;
-                    } | undefined;
-                    readonly lastIngested?: {
-                        readonly orderKey?: bigint;
-                        readonly uniqueKey?: Uint8Array;
-                    } | undefined;
-                }): StatusResponse$1;
+                create(base?: DeepPartial<StatusResponse$1>): StatusResponse$1;
+                fromPartial(object: DeepPartial<StatusResponse$1>): StatusResponse$1;
             };
             readonly responseStream: false;
             readonly options: {};
@@ -295,7 +412,7 @@ declare const stream_dataFinalityFromJSON: typeof dataFinalityFromJSON;
 declare const stream_dataFinalityToJSON: typeof dataFinalityToJSON;
 declare const stream_protobufPackage: typeof protobufPackage;
 declare namespace stream {
-  export { Data$1 as Data, DataFinality$1 as DataFinality, type stream_DeepPartial as DeepPartial, type stream_DnaStreamClient as DnaStreamClient, stream_DnaStreamDefinition as DnaStreamDefinition, type stream_DnaStreamServiceImplementation as DnaStreamServiceImplementation, Heartbeat$1 as Heartbeat, Invalidate$1 as Invalidate, type stream_ServerStreamingMethodResult as ServerStreamingMethodResult, StreamDataRequest$1 as StreamDataRequest, StreamDataResponse$1 as StreamDataResponse, SystemMessage$1 as SystemMessage, stream_dataFinalityFromJSON as dataFinalityFromJSON, stream_dataFinalityToJSON as dataFinalityToJSON, stream_protobufPackage as protobufPackage };
+  export { Cursor$1 as Cursor, Data$1 as Data, DataFinality$1 as DataFinality, 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_protobufPackage as protobufPackage };
 }
 
 /** Bytes encoded as a 0x-prefixed hex string. */
@@ -316,46 +433,64 @@ 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 | undefined) => CursorProto;
-declare const cursorFromProto: (i: CursorProto, overrideOptions?: _effect_schema_AST.ParseOptions | undefined) => 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 | undefined) => Uint8Array;
-declare const cursorFromBytes: (i: Uint8Array, overrideOptions?: _effect_schema_AST.ParseOptions | undefined) => Cursor;
+declare const cursorToBytes: (a: Cursor, overrideOptions?: _effect_schema_AST.ParseOptions) => Uint8Array;
+declare const cursorFromBytes: (i: Uint8Array, overrideOptions?: _effect_schema_AST.ParseOptions) => 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 | undefined) => {};
-declare const statusRequestFromProto: (i: {}, overrideOptions?: _effect_schema_AST.ParseOptions | undefined) => {};
+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;
-}, overrideOptions?: _effect_schema_AST.ParseOptions | 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;
-}, overrideOptions?: _effect_schema_AST.ParseOptions | 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;
+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;
@@ -369,6 +504,13 @@ declare const Invalidate: Schema.Struct<{
     }>;
 }>;
 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>;
 }>;
@@ -410,6 +552,11 @@ declare const ResponseWithoutData: Schema.Union<[Schema.Struct<{
     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<{
@@ -438,6 +585,11 @@ declare const StreamDataResponse: <TA, TR>(data: Schema.Schema<TA | null, Uint8A
     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<{
@@ -479,6 +631,10 @@ declare class StreamConfig<TFilter, TBlock> {
         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<{
@@ -494,6 +650,11 @@ declare class StreamConfig<TFilter, TBlock> {
         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<{
@@ -525,8 +686,13 @@ interface Client<TFilter, TBlock> {
     /** 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, defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<DnaStreamDefinition>>): GrpcClient<TFilter, TBlock>;
+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;
@@ -535,6 +701,8 @@ declare class GrpcClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     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>;
 }
@@ -546,4 +714,4 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-export { type Client as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, createClient as E, StreamDataIterable as F, GrpcClient as G, Heartbeat as H, Invalidate as I, DataFinality$1 as J, StatusRequest as S, _Cursor as _, DnaStreamDefinition as a, BytesFromUint8Array as b, common as c, Cursor as d, createCursor as e, cursorToProto as f, cursorFromProto as g, CursorFromBytes as h, cursorToBytes as i, cursorFromBytes as j, statusRequestToProto as k, statusRequestFromProto as l, StatusResponse as m, statusResponseToProto as n, statusResponseFromProto as o, DataFinality as p, StreamDataRequest as q, StdOut as r, stream as s, StdErr as t, SystemMessage as u, Data as v, StreamDataResponse as w, StreamConfig as x, type ClientCallOptions as y, type StreamDataOptions as z };
+export { type Client as A, Bytes as B, type CursorProto as C, type DnaStreamClient as D, type CreateClientOptions as E, Finalize as F, createClient as G, Heartbeat as H, Invalidate as I, GrpcClient as J, StreamDataIterable as K, DataFinality$1 as L, StatusRequest as S, _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, statusRequestToProto as j, statusRequestFromProto as k, StatusResponse as l, statusResponseToProto as m, statusResponseFromProto as n, DataFinality as o, Duration as p, StreamDataRequest as q, StdOut as r, stream as s, StdErr as t, SystemMessage as u, Data as v, StreamDataResponse as w, StreamConfig as x, type ClientCallOptions as y, type StreamDataOptions as z };