@s2-dev/streamstore 0.2.6 → 0.2.7

package/src/models/components/assignment.ts

@@ -10,7 +10,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 /**
  * Explicit cell assignment, if it is owned by the account.
  */
-export type Two = {
+export type Cell = {
   /**
    * Explicit cell assignment, if it is owned by the account.
    */
@@ -20,7 +20,7 @@ export type Two = {
 /**
  * Basin scope. It should be formatted as "{cloud}:{region}", e.g. "aws:us-east-1".
  */
-export type Assignment1 = {
+export type Scope = {
   /**
    * Basin scope. It should be formatted as "{cloud}:{region}", e.g. "aws:us-east-1".
    */
@@ -30,22 +30,22 @@ export type Assignment1 = {
 /**
  * Assignment of the basin to a cloud and region, or an explicit cell.
  */
-export type Assignment = Assignment1 | Two;
+export type Assignment = Scope | Cell;
 
 /** @internal */
-export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z
+export const Cell$inboundSchema: z.ZodType<Cell, z.ZodTypeDef, unknown> = z
   .object({
     cell: z.string(),
   });
 
 /** @internal */
-export type Two$Outbound = {
+export type Cell$Outbound = {
   cell: string;
 };
 
 /** @internal */
-export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
-  .object({
+export const Cell$outboundSchema: z.ZodType<Cell$Outbound, z.ZodTypeDef, Cell> =
+  z.object({
     cell: z.string(),
   });
 
@@ -53,48 +53,45 @@ export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Two$ {
-  /** @deprecated use `Two$inboundSchema` instead. */
-  export const inboundSchema = Two$inboundSchema;
-  /** @deprecated use `Two$outboundSchema` instead. */
-  export const outboundSchema = Two$outboundSchema;
-  /** @deprecated use `Two$Outbound` instead. */
-  export type Outbound = Two$Outbound;
+export namespace Cell$ {
+  /** @deprecated use `Cell$inboundSchema` instead. */
+  export const inboundSchema = Cell$inboundSchema;
+  /** @deprecated use `Cell$outboundSchema` instead. */
+  export const outboundSchema = Cell$outboundSchema;
+  /** @deprecated use `Cell$Outbound` instead. */
+  export type Outbound = Cell$Outbound;
 }
 
-export function twoToJSON(two: Two): string {
-  return JSON.stringify(Two$outboundSchema.parse(two));
+export function cellToJSON(cell: Cell): string {
+  return JSON.stringify(Cell$outboundSchema.parse(cell));
 }
 
-export function twoFromJSON(
+export function cellFromJSON(
   jsonString: string,
-): SafeParseResult<Two, SDKValidationError> {
+): SafeParseResult<Cell, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Two$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Two' from JSON`,
+    (x) => Cell$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Cell' from JSON`,
   );
 }
 
 /** @internal */
-export const Assignment1$inboundSchema: z.ZodType<
-  Assignment1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  scope: z.string(),
-});
+export const Scope$inboundSchema: z.ZodType<Scope, z.ZodTypeDef, unknown> = z
+  .object({
+    scope: z.string(),
+  });
 
 /** @internal */
-export type Assignment1$Outbound = {
+export type Scope$Outbound = {
   scope: string;
 };
 
 /** @internal */
-export const Assignment1$outboundSchema: z.ZodType<
-  Assignment1$Outbound,
+export const Scope$outboundSchema: z.ZodType<
+  Scope$Outbound,
   z.ZodTypeDef,
-  Assignment1
+  Scope
 > = z.object({
   scope: z.string(),
 });
@@ -103,26 +100,26 @@ export const Assignment1$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Assignment1$ {
-  /** @deprecated use `Assignment1$inboundSchema` instead. */
-  export const inboundSchema = Assignment1$inboundSchema;
-  /** @deprecated use `Assignment1$outboundSchema` instead. */
-  export const outboundSchema = Assignment1$outboundSchema;
-  /** @deprecated use `Assignment1$Outbound` instead. */
-  export type Outbound = Assignment1$Outbound;
+export namespace Scope$ {
+  /** @deprecated use `Scope$inboundSchema` instead. */
+  export const inboundSchema = Scope$inboundSchema;
+  /** @deprecated use `Scope$outboundSchema` instead. */
+  export const outboundSchema = Scope$outboundSchema;
+  /** @deprecated use `Scope$Outbound` instead. */
+  export type Outbound = Scope$Outbound;
 }
 
-export function assignment1ToJSON(assignment1: Assignment1): string {
-  return JSON.stringify(Assignment1$outboundSchema.parse(assignment1));
+export function scopeToJSON(scope: Scope): string {
+  return JSON.stringify(Scope$outboundSchema.parse(scope));
 }
 
-export function assignment1FromJSON(
+export function scopeFromJSON(
   jsonString: string,
-): SafeParseResult<Assignment1, SDKValidationError> {
+): SafeParseResult<Scope, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Assignment1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Assignment1' from JSON`,
+    (x) => Scope$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Scope' from JSON`,
   );
 }
 
@@ -132,12 +129,12 @@ export const Assignment$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => Assignment1$inboundSchema),
-  z.lazy(() => Two$inboundSchema),
+  z.lazy(() => Scope$inboundSchema),
+  z.lazy(() => Cell$inboundSchema),
 ]);
 
 /** @internal */
-export type Assignment$Outbound = Assignment1$Outbound | Two$Outbound;
+export type Assignment$Outbound = Scope$Outbound | Cell$Outbound;
 
 /** @internal */
 export const Assignment$outboundSchema: z.ZodType<
@@ -145,8 +142,8 @@ export const Assignment$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Assignment
 > = z.union([
-  z.lazy(() => Assignment1$outboundSchema),
-  z.lazy(() => Two$outboundSchema),
+  z.lazy(() => Scope$outboundSchema),
+  z.lazy(() => Cell$outboundSchema),
 ]);
 
 /**

package/src/models/components/output.ts

@@ -20,7 +20,7 @@ import {
  * @remarks
  * If returned in a streaming read session, this will be a terminal reply.
  */
-export type Three = {
+export type NextSeqNum = {
   /**
    * Sequence number for the next record on this stream, in case the requested `start_seq_num` was larger.
    *
@@ -37,7 +37,7 @@ export type Three = {
  * If returned in a streaming read session, this will be a terminal reply, to signal that there is uncertainty about whether some records may be omitted.
  * The client can re-establish the session starting at this sequence number.
  */
-export type Output2 = {
+export type FirstSeqNum = {
   /**
    * Sequence number for the first record on this stream, in case the requested `start_seq_num` is smaller.
    *
@@ -55,7 +55,7 @@ export type Output2 = {
  * This batch can be empty only if a `ReadLimit` was provided in the associated read request, but the first record
  * that could have been returned would violate the limit.
  */
-export type Output1 = {
+export type Batch = {
   /**
    * A batch of sequenced records.
    */
@@ -65,28 +65,31 @@ export type Output1 = {
 /**
  * Reply which can be a batch of records, or a sequence number if the request could not be satisfied.
  */
-export type Output = Output1 | Output2 | Three;
+export type Output = Batch | FirstSeqNum | NextSeqNum;
 
 /** @internal */
-export const Three$inboundSchema: z.ZodType<Three, z.ZodTypeDef, unknown> = z
-  .object({
-    next_seq_num: z.number().int(),
-  }).transform((v) => {
-    return remap$(v, {
-      "next_seq_num": "nextSeqNum",
-    });
+export const NextSeqNum$inboundSchema: z.ZodType<
+  NextSeqNum,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  next_seq_num: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "next_seq_num": "nextSeqNum",
   });
+});
 
 /** @internal */
-export type Three$Outbound = {
+export type NextSeqNum$Outbound = {
   next_seq_num: number;
 };
 
 /** @internal */
-export const Three$outboundSchema: z.ZodType<
-  Three$Outbound,
+export const NextSeqNum$outboundSchema: z.ZodType<
+  NextSeqNum$Outbound,
   z.ZodTypeDef,
-  Three
+  NextSeqNum
 > = z.object({
   nextSeqNum: z.number().int(),
 }).transform((v) => {
@@ -99,49 +102,52 @@ export const Three$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Three$ {
-  /** @deprecated use `Three$inboundSchema` instead. */
-  export const inboundSchema = Three$inboundSchema;
-  /** @deprecated use `Three$outboundSchema` instead. */
-  export const outboundSchema = Three$outboundSchema;
-  /** @deprecated use `Three$Outbound` instead. */
-  export type Outbound = Three$Outbound;
+export namespace NextSeqNum$ {
+  /** @deprecated use `NextSeqNum$inboundSchema` instead. */
+  export const inboundSchema = NextSeqNum$inboundSchema;
+  /** @deprecated use `NextSeqNum$outboundSchema` instead. */
+  export const outboundSchema = NextSeqNum$outboundSchema;
+  /** @deprecated use `NextSeqNum$Outbound` instead. */
+  export type Outbound = NextSeqNum$Outbound;
 }
 
-export function threeToJSON(three: Three): string {
-  return JSON.stringify(Three$outboundSchema.parse(three));
+export function nextSeqNumToJSON(nextSeqNum: NextSeqNum): string {
+  return JSON.stringify(NextSeqNum$outboundSchema.parse(nextSeqNum));
 }
 
-export function threeFromJSON(
+export function nextSeqNumFromJSON(
   jsonString: string,
-): SafeParseResult<Three, SDKValidationError> {
+): SafeParseResult<NextSeqNum, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Three$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Three' from JSON`,
+    (x) => NextSeqNum$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'NextSeqNum' from JSON`,
   );
 }
 
 /** @internal */
-export const Output2$inboundSchema: z.ZodType<Output2, z.ZodTypeDef, unknown> =
-  z.object({
-    first_seq_num: z.number().int(),
-  }).transform((v) => {
-    return remap$(v, {
-      "first_seq_num": "firstSeqNum",
-    });
+export const FirstSeqNum$inboundSchema: z.ZodType<
+  FirstSeqNum,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  first_seq_num: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "first_seq_num": "firstSeqNum",
   });
+});
 
 /** @internal */
-export type Output2$Outbound = {
+export type FirstSeqNum$Outbound = {
   first_seq_num: number;
 };
 
 /** @internal */
-export const Output2$outboundSchema: z.ZodType<
-  Output2$Outbound,
+export const FirstSeqNum$outboundSchema: z.ZodType<
+  FirstSeqNum$Outbound,
   z.ZodTypeDef,
-  Output2
+  FirstSeqNum
 > = z.object({
   firstSeqNum: z.number().int(),
 }).transform((v) => {
@@ -154,45 +160,45 @@ export const Output2$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Output2$ {
-  /** @deprecated use `Output2$inboundSchema` instead. */
-  export const inboundSchema = Output2$inboundSchema;
-  /** @deprecated use `Output2$outboundSchema` instead. */
-  export const outboundSchema = Output2$outboundSchema;
-  /** @deprecated use `Output2$Outbound` instead. */
-  export type Outbound = Output2$Outbound;
+export namespace FirstSeqNum$ {
+  /** @deprecated use `FirstSeqNum$inboundSchema` instead. */
+  export const inboundSchema = FirstSeqNum$inboundSchema;
+  /** @deprecated use `FirstSeqNum$outboundSchema` instead. */
+  export const outboundSchema = FirstSeqNum$outboundSchema;
+  /** @deprecated use `FirstSeqNum$Outbound` instead. */
+  export type Outbound = FirstSeqNum$Outbound;
 }
 
-export function output2ToJSON(output2: Output2): string {
-  return JSON.stringify(Output2$outboundSchema.parse(output2));
+export function firstSeqNumToJSON(firstSeqNum: FirstSeqNum): string {
+  return JSON.stringify(FirstSeqNum$outboundSchema.parse(firstSeqNum));
 }
 
-export function output2FromJSON(
+export function firstSeqNumFromJSON(
   jsonString: string,
-): SafeParseResult<Output2, SDKValidationError> {
+): SafeParseResult<FirstSeqNum, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Output2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Output2' from JSON`,
+    (x) => FirstSeqNum$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FirstSeqNum' from JSON`,
   );
 }
 
 /** @internal */
-export const Output1$inboundSchema: z.ZodType<Output1, z.ZodTypeDef, unknown> =
-  z.object({
+export const Batch$inboundSchema: z.ZodType<Batch, z.ZodTypeDef, unknown> = z
+  .object({
     batch: SequencedRecordBatch$inboundSchema,
   });
 
 /** @internal */
-export type Output1$Outbound = {
+export type Batch$Outbound = {
   batch: SequencedRecordBatch$Outbound;
 };
 
 /** @internal */
-export const Output1$outboundSchema: z.ZodType<
-  Output1$Outbound,
+export const Batch$outboundSchema: z.ZodType<
+  Batch$Outbound,
   z.ZodTypeDef,
-  Output1
+  Batch
 > = z.object({
   batch: SequencedRecordBatch$outboundSchema,
 });
@@ -201,42 +207,42 @@ export const Output1$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace Output1$ {
-  /** @deprecated use `Output1$inboundSchema` instead. */
-  export const inboundSchema = Output1$inboundSchema;
-  /** @deprecated use `Output1$outboundSchema` instead. */
-  export const outboundSchema = Output1$outboundSchema;
-  /** @deprecated use `Output1$Outbound` instead. */
-  export type Outbound = Output1$Outbound;
+export namespace Batch$ {
+  /** @deprecated use `Batch$inboundSchema` instead. */
+  export const inboundSchema = Batch$inboundSchema;
+  /** @deprecated use `Batch$outboundSchema` instead. */
+  export const outboundSchema = Batch$outboundSchema;
+  /** @deprecated use `Batch$Outbound` instead. */
+  export type Outbound = Batch$Outbound;
 }
 
-export function output1ToJSON(output1: Output1): string {
-  return JSON.stringify(Output1$outboundSchema.parse(output1));
+export function batchToJSON(batch: Batch): string {
+  return JSON.stringify(Batch$outboundSchema.parse(batch));
 }
 
-export function output1FromJSON(
+export function batchFromJSON(
   jsonString: string,
-): SafeParseResult<Output1, SDKValidationError> {
+): SafeParseResult<Batch, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Output1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Output1' from JSON`,
+    (x) => Batch$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Batch' from JSON`,
   );
 }
 
 /** @internal */
 export const Output$inboundSchema: z.ZodType<Output, z.ZodTypeDef, unknown> = z
   .union([
-    z.lazy(() => Output1$inboundSchema),
-    z.lazy(() => Output2$inboundSchema),
-    z.lazy(() => Three$inboundSchema),
+    z.lazy(() => Batch$inboundSchema),
+    z.lazy(() => FirstSeqNum$inboundSchema),
+    z.lazy(() => NextSeqNum$inboundSchema),
   ]);
 
 /** @internal */
 export type Output$Outbound =
-  | Output1$Outbound
-  | Output2$Outbound
-  | Three$Outbound;
+  | Batch$Outbound
+  | FirstSeqNum$Outbound
+  | NextSeqNum$Outbound;
 
 /** @internal */
 export const Output$outboundSchema: z.ZodType<
@@ -244,9 +250,9 @@ export const Output$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Output
 > = z.union([
-  z.lazy(() => Output1$outboundSchema),
-  z.lazy(() => Output2$outboundSchema),
-  z.lazy(() => Three$outboundSchema),
+  z.lazy(() => Batch$outboundSchema),
+  z.lazy(() => FirstSeqNum$outboundSchema),
+  z.lazy(() => NextSeqNum$outboundSchema),
 ]);
 
 /**

package/src/models/components/readresponse.ts

@@ -13,12 +13,12 @@ import {
   Output$outboundSchema,
 } from "./output.js";
 
-export type ReadResponse2 = {
+export type ErrorT = {
   data: string;
   event: string;
 };
 
-export type ReadResponse1 = {
+export type ReadResponseOutput = {
   /**
    * Reply which can be a batch of records, or a sequence number if the request could not be satisfied.
    */
@@ -26,29 +26,26 @@ export type ReadResponse1 = {
   event: string;
 };
 
-export type ReadResponse = ReadResponse1 | ReadResponse2;
+export type ReadResponse = ReadResponseOutput | ErrorT;
 
 /** @internal */
-export const ReadResponse2$inboundSchema: z.ZodType<
-  ReadResponse2,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  data: z.string(),
-  event: z.string(),
-});
+export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
+  .object({
+    data: z.string(),
+    event: z.string(),
+  });
 
 /** @internal */
-export type ReadResponse2$Outbound = {
+export type ErrorT$Outbound = {
   data: string;
   event: string;
 };
 
 /** @internal */
-export const ReadResponse2$outboundSchema: z.ZodType<
-  ReadResponse2$Outbound,
+export const ErrorT$outboundSchema: z.ZodType<
+  ErrorT$Outbound,
   z.ZodTypeDef,
-  ReadResponse2
+  ErrorT
 > = z.object({
   data: z.string(),
   event: z.string(),
@@ -58,32 +55,32 @@ export const ReadResponse2$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ReadResponse2$ {
-  /** @deprecated use `ReadResponse2$inboundSchema` instead. */
-  export const inboundSchema = ReadResponse2$inboundSchema;
-  /** @deprecated use `ReadResponse2$outboundSchema` instead. */
-  export const outboundSchema = ReadResponse2$outboundSchema;
-  /** @deprecated use `ReadResponse2$Outbound` instead. */
-  export type Outbound = ReadResponse2$Outbound;
+export namespace ErrorT$ {
+  /** @deprecated use `ErrorT$inboundSchema` instead. */
+  export const inboundSchema = ErrorT$inboundSchema;
+  /** @deprecated use `ErrorT$outboundSchema` instead. */
+  export const outboundSchema = ErrorT$outboundSchema;
+  /** @deprecated use `ErrorT$Outbound` instead. */
+  export type Outbound = ErrorT$Outbound;
 }
 
-export function readResponse2ToJSON(readResponse2: ReadResponse2): string {
-  return JSON.stringify(ReadResponse2$outboundSchema.parse(readResponse2));
+export function errorToJSON(errorT: ErrorT): string {
+  return JSON.stringify(ErrorT$outboundSchema.parse(errorT));
 }
 
-export function readResponse2FromJSON(
+export function errorFromJSON(
   jsonString: string,
-): SafeParseResult<ReadResponse2, SDKValidationError> {
+): SafeParseResult<ErrorT, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ReadResponse2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ReadResponse2' from JSON`,
+    (x) => ErrorT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorT' from JSON`,
   );
 }
 
 /** @internal */
-export const ReadResponse1$inboundSchema: z.ZodType<
-  ReadResponse1,
+export const ReadResponseOutput$inboundSchema: z.ZodType<
+  ReadResponseOutput,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -102,16 +99,16 @@ export const ReadResponse1$inboundSchema: z.ZodType<
 });
 
 /** @internal */
-export type ReadResponse1$Outbound = {
+export type ReadResponseOutput$Outbound = {
   data: Output$Outbound;
   event: string;
 };
 
 /** @internal */
-export const ReadResponse1$outboundSchema: z.ZodType<
-  ReadResponse1$Outbound,
+export const ReadResponseOutput$outboundSchema: z.ZodType<
+  ReadResponseOutput$Outbound,
   z.ZodTypeDef,
-  ReadResponse1
+  ReadResponseOutput
 > = z.object({
   data: Output$outboundSchema,
   event: z.string(),
@@ -121,26 +118,30 @@ export const ReadResponse1$outboundSchema: z.ZodType<
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace ReadResponse1$ {
-  /** @deprecated use `ReadResponse1$inboundSchema` instead. */
-  export const inboundSchema = ReadResponse1$inboundSchema;
-  /** @deprecated use `ReadResponse1$outboundSchema` instead. */
-  export const outboundSchema = ReadResponse1$outboundSchema;
-  /** @deprecated use `ReadResponse1$Outbound` instead. */
-  export type Outbound = ReadResponse1$Outbound;
+export namespace ReadResponseOutput$ {
+  /** @deprecated use `ReadResponseOutput$inboundSchema` instead. */
+  export const inboundSchema = ReadResponseOutput$inboundSchema;
+  /** @deprecated use `ReadResponseOutput$outboundSchema` instead. */
+  export const outboundSchema = ReadResponseOutput$outboundSchema;
+  /** @deprecated use `ReadResponseOutput$Outbound` instead. */
+  export type Outbound = ReadResponseOutput$Outbound;
 }
 
-export function readResponse1ToJSON(readResponse1: ReadResponse1): string {
-  return JSON.stringify(ReadResponse1$outboundSchema.parse(readResponse1));
+export function readResponseOutputToJSON(
+  readResponseOutput: ReadResponseOutput,
+): string {
+  return JSON.stringify(
+    ReadResponseOutput$outboundSchema.parse(readResponseOutput),
+  );
 }
 
-export function readResponse1FromJSON(
+export function readResponseOutputFromJSON(
   jsonString: string,
-): SafeParseResult<ReadResponse1, SDKValidationError> {
+): SafeParseResult<ReadResponseOutput, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ReadResponse1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ReadResponse1' from JSON`,
+    (x) => ReadResponseOutput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReadResponseOutput' from JSON`,
   );
 }
 
@@ -150,14 +151,14 @@ export const ReadResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => ReadResponse1$inboundSchema),
-  z.lazy(() => ReadResponse2$inboundSchema),
+  z.lazy(() => ReadResponseOutput$inboundSchema),
+  z.lazy(() => ErrorT$inboundSchema),
 ]);
 
 /** @internal */
 export type ReadResponse$Outbound =
-  | ReadResponse1$Outbound
-  | ReadResponse2$Outbound;
+  | ReadResponseOutput$Outbound
+  | ErrorT$Outbound;
 
 /** @internal */
 export const ReadResponse$outboundSchema: z.ZodType<
@@ -165,8 +166,8 @@ export const ReadResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReadResponse
 > = z.union([
-  z.lazy(() => ReadResponse1$outboundSchema),
-  z.lazy(() => ReadResponse2$outboundSchema),
+  z.lazy(() => ReadResponseOutput$outboundSchema),
+  z.lazy(() => ErrorT$outboundSchema),
 ]);
 
 /**