@apibara/protocol 2.1.0-beta.23 → 2.1.0-beta.24

package/dist/shared/{protocol.4b1cfe2c.d.cts → protocol.68a15d69.d.mts}

@@ -1,8 +1,7 @@
-import { Schema } from '@effect/schema';
-import { DefaultCallOptions, NormalizedServiceDefinition, ChannelCredentials, ChannelOptions } from 'nice-grpc';
+import { Codec, CodecProto, CodecType, MessageCodec } from '../codec.mjs';
 import { CallContext, CallOptions } from 'nice-grpc-common';
 import _m0 from 'protobufjs/minimal.js';
-import * as _effect_schema_AST from '@effect/schema/AST';
+import { DefaultCallOptions, NormalizedServiceDefinition, ChannelCredentials, ChannelOptions } from 'nice-grpc';
 
 /**
  * A Duration represents a signed, fixed-length span of time represented
@@ -70,7 +69,7 @@ interface Duration$1 {
      * 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;
+    readonly seconds?: bigint | undefined;
     /**
      * Signed fractions of a second at nanosecond resolution of the span
      * of time. Durations less than one second are represented with a 0
@@ -79,7 +78,7 @@ interface Duration$1 {
      * of the same sign as the `seconds` field. Must be from -999,999,999
      * to +999,999,999 inclusive.
      */
-    readonly nanos: number;
+    readonly nanos?: number | undefined;
 }
 declare const Duration$1: {
     encode(message: Duration$1, writer?: _m0.Writer): _m0.Writer;
@@ -133,13 +132,13 @@ interface Cursor$1 {
      *
      * This is usually the block or slot number.
      */
-    readonly orderKey: bigint;
+    readonly orderKey?: bigint | undefined;
     /**
      * Key used to discriminate branches in the stream.
      *
      * This is usually the hash of the block.
      */
-    readonly uniqueKey: Uint8Array;
+    readonly uniqueKey?: Uint8Array | undefined;
 }
 declare const Cursor$1: {
     encode(message: Cursor$1, writer?: _m0.Writer): _m0.Writer;
@@ -195,7 +194,7 @@ interface StreamDataRequest$1 {
      */
     readonly finality?: DataFinality$1 | undefined;
     /** Filters used to generate data. */
-    readonly filter: readonly Uint8Array[];
+    readonly filter?: readonly Uint8Array[] | undefined;
     /**
      * Heartbeat interval.
      *
@@ -248,7 +247,7 @@ interface Invalidate$1 {
      */
     readonly cursor?: Cursor$1 | undefined;
     /** List of blocks that were removed from the chain. */
-    readonly removed: readonly Cursor$1[];
+    readonly removed?: readonly Cursor$1[] | undefined;
 }
 declare const Invalidate$1: {
     encode(message: Invalidate$1, writer?: _m0.Writer): _m0.Writer;
@@ -290,15 +289,15 @@ interface Data$1 {
     /** Block cursor. Use this cursor to resume the stream. */
     readonly endCursor?: Cursor$1 | undefined;
     /** The finality status of the block. */
-    readonly finality: DataFinality$1;
+    readonly finality?: DataFinality$1 | undefined;
     /**
      * The block data.
      *
      * This message contains chain-specific data serialized using protobuf.
      */
-    readonly data: readonly Uint8Array[];
+    readonly data?: readonly Uint8Array[] | undefined;
     /** The production mode of the block. */
-    readonly production: DataProduction$1;
+    readonly production?: DataProduction$1 | undefined;
 }
 declare const Data$1: {
     encode(message: Data$1, writer?: _m0.Writer): _m0.Writer;
@@ -431,28 +430,20 @@ declare namespace stream {
 }
 
 /** 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>;
-}>;
+type Bytes = `0x${string}`;
+declare const BytesFromUint8Array: Codec<`0x${string}` | undefined, Uint8Array | undefined>;
+type _CursorApp = {
+    orderKey: bigint;
+    uniqueKey?: Bytes | undefined;
+};
+type _CursorProto = Cursor$1;
 /** 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;
+type CursorProto = CodecProto<typeof Cursor>;
+/** Represent a position in the stream. */
+declare const Cursor: Codec<_CursorApp, _CursorProto>;
+type Cursor = CodecType<typeof Cursor>;
+declare const createCursor: (props: Cursor) => _CursorApp;
+declare const CursorFromBytes: Codec<Cursor, Uint8Array>;
 declare function isCursor(value: unknown): value is Cursor;
 /** Normalize a cursor.
  *
@@ -467,185 +458,269 @@ declare function normalizeCursor(cursor: {
 }): 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) => {};
+declare const StatusRequest: MessageCodec<{}>;
+type StatusRequest = CodecType<typeof StatusRequest>;
 /** 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>>;
+declare const StatusResponse: MessageCodec<{
+    currentHead: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
+    lastIngested: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
+    finalized: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
+    starting: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
 }>;
-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;
-};
+type StatusResponse = CodecType<typeof StatusResponse>;
 
 /** 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 DataFinality: Codec<"finalized" | "accepted" | "pending" | "unknown", DataFinality$1>;
+type DataFinality = CodecType<typeof DataFinality>;
 /** 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;
+declare const DataProduction: Codec<"backfill" | "live" | "unknown", DataProduction$1>;
+type DataProduction = CodecType<typeof DataProduction>;
+declare const DurationCodec: MessageCodec<{
+    seconds: Codec<bigint, bigint>;
+    nanos: Codec<number, number>;
 }>;
+type Duration = CodecType<typeof DurationCodec>;
 /** 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>>;
-    }>;
+declare const StreamDataRequest: <TA>(filter: Codec<TA, Uint8Array>) => MessageCodec<{
+    finality: Codec<"finalized" | "accepted" | "pending" | "unknown" | undefined, DataFinality$1 | undefined>;
+    startingCursor: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
+    filter: Codec<TA[], Uint8Array[]>;
+    heartbeatInterval: Codec<{
+        seconds: bigint;
+        nanos: number;
+    } | undefined, {
+        seconds: bigint;
+        nanos: number;
+    } | undefined>;
 }>;
-type Finalize = typeof Finalize.Type;
-declare const Heartbeat: Schema.Struct<{
-    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+type StreamDataRequest<TA> = CodecType<ReturnType<typeof StreamDataRequest<TA>>>;
+declare const Invalidate: MessageCodec<{
+    cursor: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
 }>;
-type Heartbeat = typeof Heartbeat.Type;
-declare const StdOut: Schema.Struct<{
-    _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
-    stdout: typeof Schema.String;
+type Invalidate = CodecType<typeof Invalidate>;
+declare const Finalize: MessageCodec<{
+    cursor: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
 }>;
-type StdOut = typeof StdOut.Type;
-declare const StdErr: Schema.Struct<{
-    _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
-    stderr: typeof Schema.String;
+type Finalize = CodecType<typeof Finalize>;
+declare const Heartbeat: Codec<undefined, undefined>;
+type Heartbeat = CodecType<typeof Heartbeat>;
+declare const StdOut: Codec<string, string>;
+type StdOut = CodecType<typeof StdOut>;
+declare const StdErr: Codec<string, string>;
+type StdErr = CodecType<typeof StdErr>;
+declare const SystemMessage: MessageCodec<{
+    output: Codec<({
+        _tag: "stdout";
+    } & {
+        stdout: string;
+    }) | ({
+        _tag: "stderr";
+    } & {
+        stderr: string;
+    }), ({
+        $case: "stdout";
+    } & {
+        stdout: string;
+    }) | ({
+        $case: "stderr";
+    } & {
+        stderr: 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>>;
-    }>;
+type SystemMessage = CodecType<typeof SystemMessage>;
+declare const Data: <TA>(schema: Codec<TA | null, Uint8Array>) => MessageCodec<{
+    cursor: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    } | undefined, Cursor$1 | undefined>;
+    endCursor: Codec<{
+        orderKey: bigint;
+        uniqueKey?: Bytes | undefined;
+    }, Cursor$1>;
+    finality: Codec<"finalized" | "accepted" | "pending" | "unknown", DataFinality$1>;
+    production: Codec<"unknown" | "backfill" | "live", DataProduction$1>;
+    data: Codec<readonly (TA | null)[], readonly Uint8Array[] | undefined>;
 }>;
-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 | {
+type Data<TA> = CodecType<ReturnType<typeof Data<TA>>>;
+declare const ResponseWithoutData: Codec<({
+    _tag: "invalidate";
+} & {
+    invalidate: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "finalize";
+} & {
+    finalize: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | {
+    _tag: "heartbeat";
+} | ({
+    _tag: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            _tag: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            _tag: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+}), ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor$1 | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor$1 | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type ResponseWithoutData = CodecType<typeof ResponseWithoutData>;
+declare const StreamDataResponse: <TA>(schema: Codec<TA | null, Uint8Array>) => Codec<{
+    _tag: "heartbeat";
+} | ({
     _tag: "data";
+} & {
     data: {
-        cursor?: Cursor | undefined;
-        endCursor: Cursor;
-        finality: DataFinality;
-        production: DataProduction;
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        endCursor: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        };
+        finality: "finalized" | "accepted" | "pending" | "unknown";
+        production: "unknown" | "backfill" | "live";
         data: readonly (TA | null)[];
     };
-};
+}) | ({
+    _tag: "invalidate";
+} & {
+    invalidate: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "finalize";
+} & {
+    finalize: {
+        cursor?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+    };
+}) | ({
+    _tag: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            _tag: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            _tag: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+}), ({
+    $case: "data";
+} & {
+    data: {
+        cursor?: Cursor$1 | undefined;
+        endCursor: Cursor$1;
+        finality: DataFinality$1;
+        production: DataProduction$1;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor$1 | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor$1 | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type StreamDataResponse<TA> = CodecType<ReturnType<typeof StreamDataResponse<TA>>>;
 
 /** Configure a DNA stream. */
 declare class StreamConfig<TFilter, TBlock> {
@@ -654,55 +729,119 @@ declare class StreamConfig<TFilter, TBlock> {
     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);
+    constructor(filter: Codec<TFilter, Uint8Array>, block: Codec<TBlock | null, Uint8Array>, mergeFilter: (a: TFilter, b: TFilter) => TFilter);
     /** Filter schema. */
-    get Filter(): Schema.Schema<TFilter, Uint8Array, never>;
+    get Filter(): Codec<TFilter, Uint8Array>;
     /** Block schema. */
-    get Block(): Schema.Schema<TBlock | null, Uint8Array, never>;
+    get Block(): Codec<TBlock | null, Uint8Array>;
     /** 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;
-        }>>;
+    get Request(): MessageCodec<{
+        finality: Codec<"finalized" | "accepted" | "pending" | "unknown" | undefined, DataFinality$1 | undefined>;
+        startingCursor: Codec<{
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined, Cursor$1 | undefined>;
+        filter: Codec<TFilter[], Uint8Array[]>;
+        heartbeatInterval: Codec<{
+            seconds: bigint;
+            nanos: number;
+        } | undefined, {
+            seconds: bigint;
+            nanos: number;
+        } | undefined>;
     }>;
     /** 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;
-            }>]>;
-        }>;
-    }>]>;
+    get Response(): Codec<{
+        _tag: "heartbeat";
+    } | ({
+        _tag: "data";
+    } & {
+        data: {
+            cursor?: {
+                orderKey: bigint;
+                uniqueKey?: Bytes | undefined;
+            } | undefined;
+            endCursor: {
+                orderKey: bigint;
+                uniqueKey?: Bytes | undefined;
+            };
+            finality: "finalized" | "accepted" | "pending" | "unknown";
+            production: "unknown" | "backfill" | "live";
+            data: readonly (TBlock | null)[];
+        };
+    }) | ({
+        _tag: "invalidate";
+    } & {
+        invalidate: {
+            cursor?: {
+                orderKey: bigint;
+                uniqueKey?: Bytes | undefined;
+            } | undefined;
+        };
+    }) | ({
+        _tag: "finalize";
+    } & {
+        finalize: {
+            cursor?: {
+                orderKey: bigint;
+                uniqueKey?: Bytes | undefined;
+            } | undefined;
+        };
+    }) | ({
+        _tag: "systemMessage";
+    } & {
+        systemMessage: {
+            output: ({
+                _tag: "stdout";
+            } & {
+                stdout: string;
+            }) | ({
+                _tag: "stderr";
+            } & {
+                stderr: string;
+            });
+        };
+    }), ({
+        $case: "data";
+    } & {
+        data: {
+            cursor?: Cursor$1 | undefined;
+            endCursor: Cursor$1;
+            finality: DataFinality$1;
+            production: DataProduction$1;
+            data?: readonly Uint8Array[] | undefined;
+        };
+    }) | ({
+        $case: "invalidate";
+    } & {
+        invalidate: {
+            cursor?: Cursor$1 | undefined;
+        };
+    }) | ({
+        $case: "finalize";
+    } & {
+        finalize: {
+            cursor?: Cursor$1 | undefined;
+        };
+    }) | ({
+        $case: "heartbeat";
+    } & {
+        heartbeat: undefined;
+    }) | ({
+        $case: "systemMessage";
+    } & {
+        systemMessage: {
+            output: ({
+                $case: "stdout";
+            } & {
+                stdout: string;
+            }) | ({
+                $case: "stderr";
+            } & {
+                stderr: string;
+            });
+        };
+    })>;
 }
 
 declare class TimeoutError extends Error {
@@ -738,19 +877,31 @@ declare class GrpcClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     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;
+        currentHead?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        lastIngested?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        finalized?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
+        starting?: {
+            orderKey: bigint;
+            uniqueKey?: Bytes | undefined;
+        } | undefined;
     }>;
-    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock | null>;
 }
 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);
+    constructor(it: AsyncIterable<StreamDataResponse$1>, schema: Codec<TBlock, Uint8Array>, 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 };
+export { Cursor$1 as A, type Bytes as B, Cursor as C, type DnaStreamClient as D, DataFinality$1 as E, Finalize as F, GrpcClient as G, Heartbeat as H, Invalidate as I, DataProduction$1 as J, ResponseWithoutData as R, StatusRequest as S, TimeoutError as T, DnaStreamDefinition as a, BytesFromUint8Array as b, type CursorProto as c, createCursor as d, CursorFromBytes as e, StatusResponse as f, DataFinality as g, DataProduction as h, isCursor as i, DurationCodec as j, type Duration as k, StreamDataRequest as l, StdOut as m, normalizeCursor as n, StdErr as o, SystemMessage as p, Data as q, StreamDataResponse as r, stream as s, StreamConfig as t, type ClientCallOptions as u, type StreamDataOptions as v, type Client as w, type CreateClientOptions as x, createClient as y, StreamDataIterable as z };