@s2-dev/streamstore 0.2.8 → 0.2.10

package/src/models/operations/liststreams.ts

@@ -36,7 +36,8 @@ export type ListStreamsRequest = {
 };
 
 export type ListStreamsResponse = {
-  result: components.ListStreamsResponse;
+  httpMeta: components.HTTPMetadata;
+  listStreamsResponse?: components.ListStreamsResponse | undefined;
 };
 
 /** @internal */
@@ -113,16 +114,19 @@ export const ListStreamsResponse$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  Result: components.ListStreamsResponse$inboundSchema,
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  ListStreamsResponse: components.ListStreamsResponse$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
-    "Result": "result",
+    "HttpMeta": "httpMeta",
+    "ListStreamsResponse": "listStreamsResponse",
   });
 });
 
 /** @internal */
 export type ListStreamsResponse$Outbound = {
-  Result: components.ListStreamsResponse$Outbound;
+  HttpMeta: components.HTTPMetadata$Outbound;
+  ListStreamsResponse?: components.ListStreamsResponse$Outbound | undefined;
 };
 
 /** @internal */
@@ -131,10 +135,12 @@ export const ListStreamsResponse$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ListStreamsResponse
 > = z.object({
-  result: components.ListStreamsResponse$outboundSchema,
+  httpMeta: components.HTTPMetadata$outboundSchema,
+  listStreamsResponse: components.ListStreamsResponse$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
-    result: "Result",
+    httpMeta: "HttpMeta",
+    listStreamsResponse: "ListStreamsResponse",
   });
 });
 

package/src/models/operations/read.ts

@@ -61,9 +61,11 @@ export type ReadRequest = {
   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
@@ -233,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) {
@@ -243,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,