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

package/dist/shared/protocol.e9aed6a3.d.mts

@@ -1,549 +0,0 @@
-import { Schema } from '@effect/schema';
-import { DefaultCallOptions, NormalizedServiceDefinition } from 'nice-grpc';
-import { CallContext, CallOptions } from 'nice-grpc-common';
-import _m0 from 'protobufjs/minimal';
-import * as _effect_schema_AST from '@effect/schema/AST';
-
-declare const protobufPackage$1 = "dna.v2.common";
-/** A cursor over the stream content. */
-interface Cursor$1 {
-    /** Key used for ordering messages in the stream. */
-    readonly orderKey: bigint;
-    /** Key used to discriminate branches in the stream. */
-    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$1<Cursor$1>): Cursor$1;
-    fromPartial(object: DeepPartial$1<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$1<StatusRequest$1>): StatusRequest$1;
-    fromPartial(_: DeepPartial$1<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;
-}
-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;
-};
-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. */
-    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[];
-}
-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: "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 message before the now invalid data. */
-    readonly cursor?: Cursor$1 | undefined;
-}
-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;
-};
-/**
- * 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. */
-    readonly data: readonly Uint8Array[];
-}
-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: Uint8Array | _m0.Reader, length?: number | undefined): StatusRequest$1;
-                fromJSON(_: any): StatusRequest$1;
-                toJSON(_: StatusRequest$1): unknown;
-                create(base?: {} | undefined): StatusRequest$1;
-                fromPartial(_: {}): 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;
-                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;
-            };
-            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_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 };
-}
-
-/** 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 | undefined) => CursorProto;
-declare const cursorFromProto: (i: CursorProto, overrideOptions?: _effect_schema_AST.ParseOptions | undefined) => 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;
-
-/** 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) => {};
-/** 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>>;
-}>;
-type StatusResponse = typeof StatusResponse.Type;
-declare const statusResponseToProto: (a: {
-    readonly currentHead?: Cursor | undefined;
-    readonly lastIngested?: Cursor | undefined;
-}, overrideOptions?: _effect_schema_AST.ParseOptions | undefined) => {
-    readonly currentHead?: CursorProto | undefined;
-    readonly lastIngested?: CursorProto | undefined;
-};
-declare const statusResponseFromProto: (i: {
-    readonly currentHead?: CursorProto | undefined;
-    readonly lastIngested?: CursorProto | undefined;
-}, overrideOptions?: _effect_schema_AST.ParseOptions | undefined) => {
-    readonly currentHead?: Cursor | undefined;
-    readonly lastIngested?: 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;
-/** 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>>>;
-}>;
-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 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.optional<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.optional<Schema.Schema<Cursor, CursorProto, never>>;
-        finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "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<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
-}>, Schema.Struct<{
-    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
-    systemMessage: Schema.Struct<{
-        output: Schema.optional<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.optional<Schema.Schema<Cursor, CursorProto, never>>;
-        finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "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<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
-}>, Schema.Struct<{
-    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
-    systemMessage: Schema.Struct<{
-        output: Schema.optional<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 | undefined;
-        finality: DataFinality;
-        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>>>;
-    }>;
-    /** 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.optional<Schema.Schema<Cursor, CursorProto, never>>;
-            finality: Schema.transform<Schema.Enums<typeof DataFinality$1>, Schema.Literal<["finalized", "accepted", "pending", "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<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
-    }>, Schema.Struct<{
-        _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
-        systemMessage: Schema.Struct<{
-            output: Schema.optional<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;
-            }>]>>;
-        }>;
-    }>]>;
-}
-
-/** Client call options. */
-interface ClientCallOptions {
-    signal?: AbortSignal;
-}
-interface StreamDataOptions extends ClientCallOptions {
-    /** Stop at the specified cursor (inclusive) */
-    endingCursor?: Cursor;
-}
-/** 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>>;
-}
-/** 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 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;
-    }>;
-    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 { 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 };