@apibara/protocol 2.1.0-beta.5 → 2.1.0-beta.51

package/dist/testing/index.cjs

@@ -1,9 +1,8 @@
 'use strict';
 
-const schema = require('@effect/schema');
-const config = require('../shared/protocol.e39e40d6.cjs');
+const codec = require('../codec.cjs');
+const config = require('../shared/protocol.53f81a1e.cjs');
 require('protobufjs/minimal.js');
-require('effect');
 require('viem');
 require('long');
 
@@ -41,44 +40,31 @@ class StreamDataIterable {
   }
 }
 
-const MockFilter = schema.Schema.Struct({
-  filter: schema.Schema.optional(schema.Schema.String)
+const MockFilter = codec.MessageCodec({
+  filter: codec.OptionalCodec(codec.StringCodec)
 });
-const MockFilterFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  MockFilter,
-  {
-    strict: false,
-    decode(value) {
-      return config.MockFilter.decode(value);
-    },
-    encode(value) {
-      return config.MockFilter.encode(value).finish();
-    }
+const MockFilterFromBytes = {
+  decode(value) {
+    return config.MockFilter.decode(value);
+  },
+  encode(value) {
+    return config.MockFilter.encode(value).finish();
   }
-);
-const MockBlock = schema.Schema.Struct({
-  data: schema.Schema.optional(schema.Schema.String)
-});
-const MockBlockFromBytes = schema.Schema.transform(
-  schema.Schema.Uint8ArrayFromSelf,
-  schema.Schema.NullOr(MockBlock),
-  {
-    strict: false,
-    decode(value) {
-      if (value.length === 0) {
-        return null;
-      }
-      return config.MockBlock.decode(value);
-    },
-    encode(value) {
-      if (value === null) {
-        return new Uint8Array();
-      }
-      return config.MockBlock.encode(value).finish();
+};
+const MockBlockFromBytes = {
+  decode(value) {
+    if (value.length === 0) {
+      return null;
+    }
+    return config.MockBlock.decode(value);
+  },
+  encode(value) {
+    if (value === null) {
+      return new Uint8Array();
     }
+    return config.MockBlock.encode(value).finish();
   }
-);
+};
 function mergeMockFilter(a, b) {
   let filter = "";
   if (a.filter) {
@@ -92,7 +78,8 @@ function mergeMockFilter(a, b) {
 const MockStream = new config.StreamConfig(
   MockFilterFromBytes,
   MockBlockFromBytes,
-  mergeMockFilter
+  mergeMockFilter,
+  "mock"
 );
 const MockStreamResponse = config.StreamDataResponse(MockBlockFromBytes);
 
@@ -103,3 +90,4 @@ exports.MockFilterFromBytes = MockFilterFromBytes;
 exports.MockStream = MockStream;
 exports.MockStreamResponse = MockStreamResponse;
 exports.StreamDataIterable = StreamDataIterable;
+//# sourceMappingURL=index.cjs.map

package/dist/testing/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../src/testing/client.ts","../../src/testing/mock.ts"],"sourcesContent":["import type { Client, ClientCallOptions, StreamDataOptions } from \"../client\";\nimport type { StatusRequest, StatusResponse } from \"../status\";\nimport type { StreamDataRequest, StreamDataResponse } from \"../stream\";\n\nexport class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {\n  constructor(\n    private messageFactory: (\n      request: StreamDataRequest<TFilter>,\n      options?: StreamDataOptions,\n    ) => (StreamDataResponse<TBlock> | Error)[],\n  ) {}\n\n  async status(\n    request?: StatusRequest,\n    options?: ClientCallOptions,\n  ): Promise<StatusResponse> {\n    throw new Error(\"Client.status is not implemented for VcrClient\");\n  }\n\n  streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions) {\n    const messages = this.messageFactory(request, options);\n\n    return new StreamDataIterable(messages);\n  }\n}\n\nexport class StreamDataIterable<TBlock> {\n  constructor(private messages: (StreamDataResponse<TBlock> | Error)[]) {}\n\n  [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>> {\n    let index = 0;\n    const messages = this.messages;\n\n    return {\n      async next() {\n        if (index >= messages.length) {\n          return { done: true, value: undefined };\n        }\n\n        const message = messages[index++];\n        if (message instanceof Error) {\n          throw message;\n        }\n\n        return { done: false, value: message };\n      },\n    };\n  }\n}\n","import {\n  type Codec,\n  type CodecType,\n  MessageCodec,\n  OptionalCodec,\n  StringCodec,\n} from \"../codec\";\nimport { StreamConfig } from \"../config\";\nimport * as proto from \"../proto\";\nimport { StreamDataResponse } from \"../stream\";\n\nexport const MockFilter = MessageCodec({\n  filter: OptionalCodec(StringCodec),\n});\n\nexport type MockFilter = CodecType<typeof MockFilter>;\n\nexport const MockFilterFromBytes: Codec<MockFilter, Uint8Array> = {\n  decode(value) {\n    return proto.testing.MockFilter.decode(value);\n  },\n  encode(value) {\n    return proto.testing.MockFilter.encode(value).finish();\n  },\n};\n\nconst MockBlock = MessageCodec({\n  data: OptionalCodec(StringCodec),\n});\n\nexport type MockBlock = CodecType<typeof MockBlock>;\n\nexport const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array> = {\n  decode(value) {\n    if (value.length === 0) {\n      return null;\n    }\n    return proto.testing.MockBlock.decode(value);\n  },\n  encode(value) {\n    if (value === null) {\n      return new Uint8Array();\n    }\n    return proto.testing.MockBlock.encode(value).finish();\n  },\n};\n\n/** For testing, simply concatenate the values of `.filter` */\nfunction mergeMockFilter(a: MockFilter, b: MockFilter): MockFilter {\n  let filter = \"\";\n  if (a.filter) {\n    filter += a.filter;\n  }\n  if (b.filter) {\n    filter += b.filter;\n  }\n  return { filter };\n}\n\nexport const MockStream = new StreamConfig(\n  MockFilterFromBytes,\n  MockBlockFromBytes,\n  mergeMockFilter,\n  \"mock\",\n);\n\nexport const MockStreamResponse = StreamDataResponse(MockBlockFromBytes);\n\nexport type MockStreamResponse = CodecType<typeof MockStreamResponse>;\n"],"names":["MessageCodec","OptionalCodec","StringCodec","proto.testing.MockFilter","proto.testing.MockBlock","StreamConfig","StreamDataResponse"],"mappings":"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"}

package/dist/testing/index.d.cts

@@ -1,9 +1,8 @@
-import { J as Client, u as StreamDataRequest, G as StreamDataOptions, z as StreamDataResponse, S as StatusRequest, E as ClientCallOptions, m as StatusResponse, A as StreamConfig, c as Cursor, C as CursorProto, O as DataFinality, P as DataProduction } from '../shared/protocol.4b1cfe2c.cjs';
-import { Schema } from '@effect/schema';
-import 'nice-grpc';
+import { w as Client, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, t as StreamConfig, B as Bytes, E as Cursor, J as DataFinality, K as DataProduction } from '../shared/protocol.0e734e33.cjs';
+import { MessageCodec, Codec, CodecType } from '../codec.cjs';
 import 'nice-grpc-common';
 import 'protobufjs/minimal.js';
-import '@effect/schema/AST';
+import 'nice-grpc';
 
 declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private messageFactory;
@@ -17,60 +16,114 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-declare const MockFilter: Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
+declare const MockFilter: MessageCodec<{
+    filter: Codec<string | undefined, string | undefined>;
 }>;
-type MockFilter = typeof MockFilter.Type;
-declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
-}>>;
-declare const MockBlock: Schema.Struct<{
-    data: Schema.optional<typeof Schema.String>;
+type MockFilter = CodecType<typeof MockFilter>;
+declare const MockFilterFromBytes: Codec<MockFilter, Uint8Array>;
+declare const MockBlock: MessageCodec<{
+    data: Codec<string | undefined, string | undefined>;
 }>;
-type MockBlock = typeof MockBlock.Type;
-declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
-    data: Schema.optional<typeof Schema.String>;
-}>>>;
+type MockBlock = CodecType<typeof MockBlock>;
+declare const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array>;
 declare const MockStream: StreamConfig<{
-    readonly filter?: string | undefined;
+    filter?: string | undefined;
 }, {
-    readonly data?: string | undefined;
+    data?: string | undefined;
 }>;
-declare const MockStreamResponse: 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>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
-        production: Schema.transform<Schema.Enums<typeof DataProduction>, Schema.Literal<["backfill", "live", "unknown"]>>;
-        data: Schema.Array$<Schema.Schema<{
-            readonly data?: string | undefined;
-        } | 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;
-        }>]>;
-    }>;
-}>]>;
-type MockStreamResponse = typeof MockStreamResponse.Type;
+declare const MockStreamResponse: 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 ({
+            data?: string | undefined;
+        } | 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 | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type MockStreamResponse = CodecType<typeof MockStreamResponse>;
 
 export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.mts

@@ -1,9 +1,8 @@
-import { J as Client, u as StreamDataRequest, G as StreamDataOptions, z as StreamDataResponse, S as StatusRequest, E as ClientCallOptions, m as StatusResponse, A as StreamConfig, c as Cursor, C as CursorProto, O as DataFinality, P as DataProduction } from '../shared/protocol.4b1cfe2c.mjs';
-import { Schema } from '@effect/schema';
-import 'nice-grpc';
+import { w as Client, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, t as StreamConfig, B as Bytes, E as Cursor, J as DataFinality, K as DataProduction } from '../shared/protocol.21e66b9e.mjs';
+import { MessageCodec, Codec, CodecType } from '../codec.mjs';
 import 'nice-grpc-common';
 import 'protobufjs/minimal.js';
-import '@effect/schema/AST';
+import 'nice-grpc';
 
 declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private messageFactory;
@@ -17,60 +16,114 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-declare const MockFilter: Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
+declare const MockFilter: MessageCodec<{
+    filter: Codec<string | undefined, string | undefined>;
 }>;
-type MockFilter = typeof MockFilter.Type;
-declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
-}>>;
-declare const MockBlock: Schema.Struct<{
-    data: Schema.optional<typeof Schema.String>;
+type MockFilter = CodecType<typeof MockFilter>;
+declare const MockFilterFromBytes: Codec<MockFilter, Uint8Array>;
+declare const MockBlock: MessageCodec<{
+    data: Codec<string | undefined, string | undefined>;
 }>;
-type MockBlock = typeof MockBlock.Type;
-declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
-    data: Schema.optional<typeof Schema.String>;
-}>>>;
+type MockBlock = CodecType<typeof MockBlock>;
+declare const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array>;
 declare const MockStream: StreamConfig<{
-    readonly filter?: string | undefined;
+    filter?: string | undefined;
 }, {
-    readonly data?: string | undefined;
+    data?: string | undefined;
 }>;
-declare const MockStreamResponse: 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>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
-        production: Schema.transform<Schema.Enums<typeof DataProduction>, Schema.Literal<["backfill", "live", "unknown"]>>;
-        data: Schema.Array$<Schema.Schema<{
-            readonly data?: string | undefined;
-        } | 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;
-        }>]>;
-    }>;
-}>]>;
-type MockStreamResponse = typeof MockStreamResponse.Type;
+declare const MockStreamResponse: 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 ({
+            data?: string | undefined;
+        } | 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 | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type MockStreamResponse = CodecType<typeof MockStreamResponse>;
 
 export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.ts

@@ -1,9 +1,8 @@
-import { J as Client, u as StreamDataRequest, G as StreamDataOptions, z as StreamDataResponse, S as StatusRequest, E as ClientCallOptions, m as StatusResponse, A as StreamConfig, c as Cursor, C as CursorProto, O as DataFinality, P as DataProduction } from '../shared/protocol.4b1cfe2c.js';
-import { Schema } from '@effect/schema';
-import 'nice-grpc';
+import { w as Client, l as StreamDataRequest, v as StreamDataOptions, r as StreamDataResponse, S as StatusRequest, u as ClientCallOptions, f as StatusResponse, t as StreamConfig, B as Bytes, E as Cursor, J as DataFinality, K as DataProduction } from '../shared/protocol.8fb09325.js';
+import { MessageCodec, Codec, CodecType } from '../codec.js';
 import 'nice-grpc-common';
 import 'protobufjs/minimal.js';
-import '@effect/schema/AST';
+import 'nice-grpc';
 
 declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
     private messageFactory;
@@ -17,60 +16,114 @@ declare class StreamDataIterable<TBlock> {
     [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
 }
 
-declare const MockFilter: Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
+declare const MockFilter: MessageCodec<{
+    filter: Codec<string | undefined, string | undefined>;
 }>;
-type MockFilter = typeof MockFilter.Type;
-declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
-    filter: Schema.optional<typeof Schema.String>;
-}>>;
-declare const MockBlock: Schema.Struct<{
-    data: Schema.optional<typeof Schema.String>;
+type MockFilter = CodecType<typeof MockFilter>;
+declare const MockFilterFromBytes: Codec<MockFilter, Uint8Array>;
+declare const MockBlock: MessageCodec<{
+    data: Codec<string | undefined, string | undefined>;
 }>;
-type MockBlock = typeof MockBlock.Type;
-declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
-    data: Schema.optional<typeof Schema.String>;
-}>>>;
+type MockBlock = CodecType<typeof MockBlock>;
+declare const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array>;
 declare const MockStream: StreamConfig<{
-    readonly filter?: string | undefined;
+    filter?: string | undefined;
 }, {
-    readonly data?: string | undefined;
+    data?: string | undefined;
 }>;
-declare const MockStreamResponse: 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>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
-        production: Schema.transform<Schema.Enums<typeof DataProduction>, Schema.Literal<["backfill", "live", "unknown"]>>;
-        data: Schema.Array$<Schema.Schema<{
-            readonly data?: string | undefined;
-        } | 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;
-        }>]>;
-    }>;
-}>]>;
-type MockStreamResponse = typeof MockStreamResponse.Type;
+declare const MockStreamResponse: 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 ({
+            data?: string | undefined;
+        } | 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 | undefined;
+        endCursor: Cursor;
+        finality: DataFinality;
+        production: DataProduction;
+        data?: readonly Uint8Array[] | undefined;
+    };
+}) | ({
+    $case: "invalidate";
+} & {
+    invalidate: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "finalize";
+} & {
+    finalize: {
+        cursor?: Cursor | undefined;
+    };
+}) | ({
+    $case: "heartbeat";
+} & {
+    heartbeat: undefined;
+}) | ({
+    $case: "systemMessage";
+} & {
+    systemMessage: {
+        output: ({
+            $case: "stdout";
+        } & {
+            stdout: string;
+        }) | ({
+            $case: "stderr";
+        } & {
+            stderr: string;
+        });
+    };
+})>;
+type MockStreamResponse = CodecType<typeof MockStreamResponse>;
 
 export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };