@s2-dev/streamstore 0.2.7 → 0.2.10

package/src/models/operations/read.ts

@@ -6,7 +6,6 @@ import * as z from "zod";
 import { EventStream } from "../../lib/event-streams.js";
 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";
@@ -32,19 +31,13 @@ export type Limit = {
   count?: number | null | undefined;
 };
 
-export const One = {
-  Json: "json",
-  JsonBinsafe: "json-binsafe",
-} as const;
-export type One = ClosedEnum<typeof One>;
-
 /**
  * json: utf-8 plaintext data.
  *
  * @remarks
  * json-binsafe: base64 encoded binary data.
  */
-export type S2Format = One;
+export type S2Format = components.FormatOption;
 
 export type ReadRequest = {
   /**
@@ -61,16 +54,18 @@ export type ReadRequest = {
    * @remarks
    * json-binsafe: base64 encoded binary data.
    */
-  s2Format?: One | undefined;
+  s2Format?: components.FormatOption | undefined;
   /**
    * Name of the stream.
    */
   stream: string;
 };
 
-export type ReadResponse =
-  | components.Output
-  | EventStream<components.ReadResponse>;
+export type ReadResponse = {
+  httpMeta: components.HTTPMetadata;
+  output?: components.Output | undefined;
+  readResponse?: EventStream<components.ReadResponse> | undefined;
+};
 
 /** @internal */
 export const Limit$inboundSchema: z.ZodType<Limit, z.ZodTypeDef, unknown> = z
@@ -122,30 +117,12 @@ export function limitFromJSON(
   );
 }
 
-/** @internal */
-export const One$inboundSchema: z.ZodNativeEnum<typeof One> = z.nativeEnum(One);
-
-/** @internal */
-export const One$outboundSchema: z.ZodNativeEnum<typeof One> =
-  One$inboundSchema;
-
-/**
- * @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;
-}
-
 /** @internal */
 export const S2Format$inboundSchema: z.ZodType<
   S2Format,
   z.ZodTypeDef,
   unknown
-> = One$inboundSchema;
+> = components.FormatOption$inboundSchema;
 
 /** @internal */
 export type S2Format$Outbound = string;
@@ -155,7 +132,7 @@ export const S2Format$outboundSchema: z.ZodType<
   S2Format$Outbound,
   z.ZodTypeDef,
   S2Format
-> = One$outboundSchema;
+> = components.FormatOption$outboundSchema;
 
 /**
  * @internal
@@ -192,7 +169,7 @@ export const ReadRequest$inboundSchema: z.ZodType<
 > = z.object({
   start_seq_num: z.number().int().optional(),
   limit: z.lazy(() => Limit$inboundSchema).optional(),
-  "s2-format": One$inboundSchema.optional(),
+  "s2-format": components.FormatOption$inboundSchema.optional(),
   stream: z.string(),
 }).transform((v) => {
   return remap$(v, {
@@ -217,7 +194,7 @@ export const ReadRequest$outboundSchema: z.ZodType<
 > = z.object({
   startSeqNum: z.number().int().optional(),
   limit: z.lazy(() => Limit$outboundSchema).optional(),
-  s2Format: One$outboundSchema.optional(),
+  s2Format: components.FormatOption$outboundSchema.optional(),
   stream: z.string(),
 }).transform((v) => {
   return remap$(v, {
@@ -258,9 +235,10 @@ export const ReadResponse$inboundSchema: z.ZodType<
   ReadResponse,
   z.ZodTypeDef,
   unknown
-> = z.union([
-  components.Output$inboundSchema,
-  z.instanceof(ReadableStream<Uint8Array>).transform(stream => {
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  Output: components.Output$inboundSchema.optional(),
+  ReadResponse: z.instanceof(ReadableStream<Uint8Array>).transform(stream => {
     return new EventStream({
       stream,
       decoder(rawEvent) {
@@ -268,18 +246,38 @@ export const ReadResponse$inboundSchema: z.ZodType<
         return schema.parse(rawEvent);
       },
     });
-  }),
-]);
+  }).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "Output": "output",
+    "ReadResponse": "readResponse",
+  });
+});
 
 /** @internal */
-export type ReadResponse$Outbound = components.Output$Outbound | never;
+export type ReadResponse$Outbound = {
+  HttpMeta: components.HTTPMetadata$Outbound;
+  Output?: components.Output$Outbound | undefined;
+  ReadResponse?: never | undefined;
+};
 
 /** @internal */
 export const ReadResponse$outboundSchema: z.ZodType<
   ReadResponse$Outbound,
   z.ZodTypeDef,
   ReadResponse
-> = z.union([components.Output$outboundSchema, z.never()]);
+> = z.object({
+  httpMeta: components.HTTPMetadata$outboundSchema,
+  output: components.Output$outboundSchema.optional(),
+  readResponse: z.never().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    httpMeta: "HttpMeta",
+    output: "Output",
+    readResponse: "ReadResponse",
+  });
+});
 
 /**
  * @internal

package/src/models/operations/reconfigurebasin.ts

@@ -17,6 +17,11 @@ export type ReconfigureBasinRequest = {
   basinConfig: components.BasinConfig;
 };
 
+export type ReconfigureBasinResponse = {
+  httpMeta: components.HTTPMetadata;
+  basinConfig?: components.BasinConfig | undefined;
+};
+
 /** @internal */
 export const ReconfigureBasinRequest$inboundSchema: z.ZodType<
   ReconfigureBasinRequest,
@@ -81,3 +86,70 @@ export function reconfigureBasinRequestFromJSON(
     `Failed to parse 'ReconfigureBasinRequest' from JSON`,
   );
 }
+
+/** @internal */
+export const ReconfigureBasinResponse$inboundSchema: z.ZodType<
+  ReconfigureBasinResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  BasinConfig: components.BasinConfig$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "BasinConfig": "basinConfig",
+  });
+});
+
+/** @internal */
+export type ReconfigureBasinResponse$Outbound = {
+  HttpMeta: components.HTTPMetadata$Outbound;
+  BasinConfig?: components.BasinConfig$Outbound | undefined;
+};
+
+/** @internal */
+export const ReconfigureBasinResponse$outboundSchema: z.ZodType<
+  ReconfigureBasinResponse$Outbound,
+  z.ZodTypeDef,
+  ReconfigureBasinResponse
+> = z.object({
+  httpMeta: components.HTTPMetadata$outboundSchema,
+  basinConfig: components.BasinConfig$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    httpMeta: "HttpMeta",
+    basinConfig: "BasinConfig",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ReconfigureBasinResponse$ {
+  /** @deprecated use `ReconfigureBasinResponse$inboundSchema` instead. */
+  export const inboundSchema = ReconfigureBasinResponse$inboundSchema;
+  /** @deprecated use `ReconfigureBasinResponse$outboundSchema` instead. */
+  export const outboundSchema = ReconfigureBasinResponse$outboundSchema;
+  /** @deprecated use `ReconfigureBasinResponse$Outbound` instead. */
+  export type Outbound = ReconfigureBasinResponse$Outbound;
+}
+
+export function reconfigureBasinResponseToJSON(
+  reconfigureBasinResponse: ReconfigureBasinResponse,
+): string {
+  return JSON.stringify(
+    ReconfigureBasinResponse$outboundSchema.parse(reconfigureBasinResponse),
+  );
+}
+
+export function reconfigureBasinResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconfigureBasinResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconfigureBasinResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconfigureBasinResponse' from JSON`,
+  );
+}

package/src/models/operations/reconfigurestream.ts

@@ -24,6 +24,11 @@ export type ReconfigureStreamRequest = {
   streamConfig: components.StreamConfig;
 };
 
+export type ReconfigureStreamResponse = {
+  httpMeta: components.HTTPMetadata;
+  streamConfig?: components.StreamConfig | undefined;
+};
+
 /** @internal */
 export const ReconfigureStreamRequest$inboundSchema: z.ZodType<
   ReconfigureStreamRequest,
@@ -88,3 +93,70 @@ export function reconfigureStreamRequestFromJSON(
     `Failed to parse 'ReconfigureStreamRequest' from JSON`,
   );
 }
+
+/** @internal */
+export const ReconfigureStreamResponse$inboundSchema: z.ZodType<
+  ReconfigureStreamResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  StreamConfig: components.StreamConfig$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "StreamConfig": "streamConfig",
+  });
+});
+
+/** @internal */
+export type ReconfigureStreamResponse$Outbound = {
+  HttpMeta: components.HTTPMetadata$Outbound;
+  StreamConfig?: components.StreamConfig$Outbound | undefined;
+};
+
+/** @internal */
+export const ReconfigureStreamResponse$outboundSchema: z.ZodType<
+  ReconfigureStreamResponse$Outbound,
+  z.ZodTypeDef,
+  ReconfigureStreamResponse
+> = z.object({
+  httpMeta: components.HTTPMetadata$outboundSchema,
+  streamConfig: components.StreamConfig$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    httpMeta: "HttpMeta",
+    streamConfig: "StreamConfig",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ReconfigureStreamResponse$ {
+  /** @deprecated use `ReconfigureStreamResponse$inboundSchema` instead. */
+  export const inboundSchema = ReconfigureStreamResponse$inboundSchema;
+  /** @deprecated use `ReconfigureStreamResponse$outboundSchema` instead. */
+  export const outboundSchema = ReconfigureStreamResponse$outboundSchema;
+  /** @deprecated use `ReconfigureStreamResponse$Outbound` instead. */
+  export type Outbound = ReconfigureStreamResponse$Outbound;
+}
+
+export function reconfigureStreamResponseToJSON(
+  reconfigureStreamResponse: ReconfigureStreamResponse,
+): string {
+  return JSON.stringify(
+    ReconfigureStreamResponse$outboundSchema.parse(reconfigureStreamResponse),
+  );
+}
+
+export function reconfigureStreamResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ReconfigureStreamResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReconfigureStreamResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReconfigureStreamResponse' from JSON`,
+  );
+}

package/src/sdk/account.ts

@@ -8,7 +8,6 @@ import { accountGetBasinConfig } from "../funcs/accountGetBasinConfig.js";
 import { accountListBasins } from "../funcs/accountListBasins.js";
 import { accountReconfigureBasin } from "../funcs/accountReconfigureBasin.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
-import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 import { PageIterator, unwrapResultIterator } from "../types/operations.js";
@@ -34,7 +33,7 @@ export class Account extends ClientSDK {
   async getBasinConfig(
     request: operations.GetBasinConfigRequest,
     options?: RequestOptions,
-  ): Promise<components.BasinConfig> {
+  ): Promise<operations.GetBasinConfigResponse> {
     return unwrapAsync(accountGetBasinConfig(
       this,
       request,
@@ -48,7 +47,7 @@ export class Account extends ClientSDK {
   async createBasin(
     request: operations.CreateBasinRequest,
     options?: RequestOptions,
-  ): Promise<components.BasinInfo> {
+  ): Promise<operations.CreateBasinResponse> {
     return unwrapAsync(accountCreateBasin(
       this,
       request,
@@ -62,7 +61,7 @@ export class Account extends ClientSDK {
   async deleteBasin(
     request: operations.DeleteBasinRequest,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.DeleteBasinResponse> {
     return unwrapAsync(accountDeleteBasin(
       this,
       request,
@@ -76,7 +75,7 @@ export class Account extends ClientSDK {
   async reconfigureBasin(
     request: operations.ReconfigureBasinRequest,
     options?: RequestOptions,
-  ): Promise<components.BasinConfig> {
+  ): Promise<operations.ReconfigureBasinResponse> {
     return unwrapAsync(accountReconfigureBasin(
       this,
       request,

package/src/sdk/basin.ts

@@ -8,7 +8,6 @@ import { basinGetStreamConfig } from "../funcs/basinGetStreamConfig.js";
 import { basinListStreams } from "../funcs/basinListStreams.js";
 import { basinReconfigureStream } from "../funcs/basinReconfigureStream.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
-import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 import { PageIterator, unwrapResultIterator } from "../types/operations.js";
@@ -34,7 +33,7 @@ export class Basin extends ClientSDK {
   async getStreamConfig(
     request: operations.GetStreamConfigRequest,
     options?: RequestOptions,
-  ): Promise<components.StreamConfig> {
+  ): Promise<operations.GetStreamConfigResponse> {
     return unwrapAsync(basinGetStreamConfig(
       this,
       request,
@@ -48,7 +47,7 @@ export class Basin extends ClientSDK {
   async createStream(
     request: operations.CreateStreamRequest,
     options?: RequestOptions,
-  ): Promise<components.StreamInfo> {
+  ): Promise<operations.CreateStreamResponse> {
     return unwrapAsync(basinCreateStream(
       this,
       request,
@@ -62,7 +61,7 @@ export class Basin extends ClientSDK {
   async deleteStream(
     request: operations.DeleteStreamRequest,
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<operations.DeleteStreamResponse> {
     return unwrapAsync(basinDeleteStream(
       this,
       request,
@@ -76,7 +75,7 @@ export class Basin extends ClientSDK {
   async reconfigureStream(
     request: operations.ReconfigureStreamRequest,
     options?: RequestOptions,
-  ): Promise<components.StreamConfig> {
+  ): Promise<operations.ReconfigureStreamResponse> {
     return unwrapAsync(basinReconfigureStream(
       this,
       request,

package/src/sdk/stream.ts

@@ -6,7 +6,6 @@ import { streamAppend } from "../funcs/streamAppend.js";
 import { streamCheckTail } from "../funcs/streamCheckTail.js";
 import { ReadAcceptEnum, streamRead } from "../funcs/streamRead.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
-import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
@@ -39,7 +38,7 @@ export class Stream extends ClientSDK {
   async append(
     request: operations.AppendRequest,
     options?: RequestOptions,
-  ): Promise<components.AppendOutput> {
+  ): Promise<operations.AppendResponse> {
     return unwrapAsync(streamAppend(
       this,
       request,
@@ -56,7 +55,7 @@ export class Stream extends ClientSDK {
   async checkTail(
     request: operations.CheckTailRequest,
     options?: RequestOptions,
-  ): Promise<components.CheckTailResponse> {
+  ): Promise<operations.CheckTailResponse> {
     return unwrapAsync(streamCheckTail(
       this,
       request,