@s2-dev/streamstore 0.2.6 → 0.2.8

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),
 ]);
 
 /**

package/src/models/components/retentionpolicy.ts

@@ -13,7 +13,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
  * @remarks
  * If set to 0, the stream will have infinite retention.
  */
-export type One = {
+export type Age = {
   /**
    * Age in seconds for automatic trimming of records older than this threshold.
    *
@@ -29,21 +29,21 @@ export type One = {
  * @remarks
  * If unspecified, the default is to retain records for 7 days.
  */
-export type RetentionPolicy = One;
+export type RetentionPolicy = Age;
 
 /** @internal */
-export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
+export const Age$inboundSchema: z.ZodType<Age, z.ZodTypeDef, unknown> = z
   .object({
     age: z.number().int(),
   });
 
 /** @internal */
-export type One$Outbound = {
+export type Age$Outbound = {
   age: number;
 };
 
 /** @internal */
-export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
+export const Age$outboundSchema: z.ZodType<Age$Outbound, z.ZodTypeDef, Age> = z
   .object({
     age: z.number().int(),
   });
@@ -52,26 +52,26 @@ export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export namespace One$ {
-  /** @deprecated use `One$inboundSchema` instead. */
-  export const inboundSchema = One$inboundSchema;
-  /** @deprecated use `One$outboundSchema` instead. */
-  export const outboundSchema = One$outboundSchema;
-  /** @deprecated use `One$Outbound` instead. */
-  export type Outbound = One$Outbound;
+export namespace Age$ {
+  /** @deprecated use `Age$inboundSchema` instead. */
+  export const inboundSchema = Age$inboundSchema;
+  /** @deprecated use `Age$outboundSchema` instead. */
+  export const outboundSchema = Age$outboundSchema;
+  /** @deprecated use `Age$Outbound` instead. */
+  export type Outbound = Age$Outbound;
 }
 
-export function oneToJSON(one: One): string {
-  return JSON.stringify(One$outboundSchema.parse(one));
+export function ageToJSON(age: Age): string {
+  return JSON.stringify(Age$outboundSchema.parse(age));
 }
 
-export function oneFromJSON(
+export function ageFromJSON(
   jsonString: string,
-): SafeParseResult<One, SDKValidationError> {
+): SafeParseResult<Age, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => One$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'One' from JSON`,
+    (x) => Age$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Age' from JSON`,
   );
 }
 
@@ -80,17 +80,17 @@ export const RetentionPolicy$inboundSchema: z.ZodType<
   RetentionPolicy,
   z.ZodTypeDef,
   unknown
-> = z.lazy(() => One$inboundSchema);
+> = z.lazy(() => Age$inboundSchema);
 
 /** @internal */
-export type RetentionPolicy$Outbound = One$Outbound;
+export type RetentionPolicy$Outbound = Age$Outbound;
 
 /** @internal */
 export const RetentionPolicy$outboundSchema: z.ZodType<
   RetentionPolicy$Outbound,
   z.ZodTypeDef,
   RetentionPolicy
-> = z.lazy(() => One$outboundSchema);
+> = z.lazy(() => Age$outboundSchema);
 
 /**
  * @internal

package/src/models/operations/append.ts

@@ -5,7 +5,6 @@
 import * as z from "zod";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -17,19 +16,13 @@ export const AppendServerList = [
   "https://{basin}.b.aws.s2.dev/v1alpha",
 ] as const;
 
-export const Header1 = {
-  Json: "json",
-  JsonBinsafe: "json-binsafe",
-} as const;
-export type Header1 = ClosedEnum<typeof Header1>;
-
 /**
  * json: utf-8 plaintext data.
  *
  * @remarks
  * json-binsafe: base64 encoded binary data.
  */
-export type HeaderS2Format = Header1;
+export type HeaderS2Format = components.FormatOption;
 
 export type AppendRequest = {
   /**
@@ -38,7 +31,7 @@ export type AppendRequest = {
    * @remarks
    * json-binsafe: base64 encoded binary data.
    */
-  s2Format?: Header1 | undefined;
+  s2Format?: components.FormatOption | undefined;
   /**
    * Name of the stream.
    */
@@ -46,31 +39,12 @@ export type AppendRequest = {
   appendInput: components.AppendInput;
 };
 
-/** @internal */
-export const Header1$inboundSchema: z.ZodNativeEnum<typeof Header1> = z
-  .nativeEnum(Header1);
-
-/** @internal */
-export const Header1$outboundSchema: z.ZodNativeEnum<typeof Header1> =
-  Header1$inboundSchema;
-
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export namespace Header1$ {
-  /** @deprecated use `Header1$inboundSchema` instead. */
-  export const inboundSchema = Header1$inboundSchema;
-  /** @deprecated use `Header1$outboundSchema` instead. */
-  export const outboundSchema = Header1$outboundSchema;
-}
-
 /** @internal */
 export const HeaderS2Format$inboundSchema: z.ZodType<
   HeaderS2Format,
   z.ZodTypeDef,
   unknown
-> = Header1$inboundSchema;
+> = components.FormatOption$inboundSchema;
 
 /** @internal */
 export type HeaderS2Format$Outbound = string;
@@ -80,7 +54,7 @@ export const HeaderS2Format$outboundSchema: z.ZodType<
   HeaderS2Format$Outbound,
   z.ZodTypeDef,
   HeaderS2Format
-> = Header1$outboundSchema;
+> = components.FormatOption$outboundSchema;
 
 /**
  * @internal
@@ -115,7 +89,7 @@ export const AppendRequest$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  "s2-format": Header1$inboundSchema.optional(),
+  "s2-format": components.FormatOption$inboundSchema.optional(),
   stream: z.string(),
   AppendInput: components.AppendInput$inboundSchema,
 }).transform((v) => {
@@ -138,7 +112,7 @@ export const AppendRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AppendRequest
 > = z.object({
-  s2Format: Header1$outboundSchema.optional(),
+  s2Format: components.FormatOption$outboundSchema.optional(),
   stream: z.string(),
   appendInput: components.AppendInput$outboundSchema,
 }).transform((v) => {