@s2-dev/streamstore 0.13.3 → 0.15.0

package/src/models/components/readevent.ts

@@ -4,50 +4,120 @@
 
 import * as z from "zod";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  PingEventData,
+  PingEventData$inboundSchema,
+  PingEventData$Outbound,
+  PingEventData$outboundSchema,
+} from "./pingeventdata.js";
 import {
   ReadBatch,
   ReadBatch$inboundSchema,
   ReadBatch$Outbound,
   ReadBatch$outboundSchema,
 } from "./readbatch.js";
+import {
+  TailResponse,
+  TailResponse$inboundSchema,
+  TailResponse$Outbound,
+  TailResponse$outboundSchema,
+} from "./tailresponse.js";
+
+export const ReadEvent4Event = {
+  Ping: "ping",
+} as const;
+export type ReadEvent4Event = ClosedEnum<typeof ReadEvent4Event>;
 
 export type Ping = {
-  data: string;
-  event: string;
+  data: PingEventData;
+  event: ReadEvent4Event;
 };
 
+export const ReadEvent3Event = {
+  Error: "error",
+} as const;
+export type ReadEvent3Event = ClosedEnum<typeof ReadEvent3Event>;
+
 export type ErrorT = {
   data: string;
-  event: string;
+  event: ReadEvent3Event;
 };
 
+export const ReadEventEvent = {
+  Tail: "tail",
+} as const;
+export type ReadEventEvent = ClosedEnum<typeof ReadEventEvent>;
+
+export type ReadEvent2 = {
+  data: TailResponse;
+  event: ReadEventEvent;
+};
+
+export const Event = {
+  Batch: "batch",
+} as const;
+export type Event = ClosedEnum<typeof Event>;
+
 export type Batch = {
   data: ReadBatch;
-  event: string;
+  event: Event;
+  id: string;
 };
 
-export type ReadEvent = Batch | ErrorT | Ping;
+export type ReadEvent = ReadEvent2 | ErrorT | Ping | Batch;
+
+/** @internal */
+export const ReadEvent4Event$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent4Event
+> = z.nativeEnum(ReadEvent4Event);
+
+/** @internal */
+export const ReadEvent4Event$outboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent4Event
+> = ReadEvent4Event$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ReadEvent4Event$ {
+  /** @deprecated use `ReadEvent4Event$inboundSchema` instead. */
+  export const inboundSchema = ReadEvent4Event$inboundSchema;
+  /** @deprecated use `ReadEvent4Event$outboundSchema` instead. */
+  export const outboundSchema = ReadEvent4Event$outboundSchema;
+}
 
 /** @internal */
 export const Ping$inboundSchema: z.ZodType<Ping, z.ZodTypeDef, unknown> = z
   .object({
-    data: z.string(),
-    event: z.string(),
+    data: z.string().transform((v, ctx) => {
+      try {
+        return JSON.parse(v);
+      } catch (err) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `malformed json: ${err}`,
+        });
+        return z.NEVER;
+      }
+    }).pipe(PingEventData$inboundSchema),
+    event: ReadEvent4Event$inboundSchema,
   });
 
 /** @internal */
 export type Ping$Outbound = {
-  data: string;
+  data: PingEventData$Outbound;
   event: string;
 };
 
 /** @internal */
 export const Ping$outboundSchema: z.ZodType<Ping$Outbound, z.ZodTypeDef, Ping> =
   z.object({
-    data: z.string(),
-    event: z.string(),
+    data: PingEventData$outboundSchema,
+    event: ReadEvent4Event$outboundSchema,
   });
 
 /**
@@ -77,11 +147,32 @@ export function pingFromJSON(
   );
 }
 
+/** @internal */
+export const ReadEvent3Event$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent3Event
+> = z.nativeEnum(ReadEvent3Event);
+
+/** @internal */
+export const ReadEvent3Event$outboundSchema: z.ZodNativeEnum<
+  typeof ReadEvent3Event
+> = ReadEvent3Event$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ReadEvent3Event$ {
+  /** @deprecated use `ReadEvent3Event$inboundSchema` instead. */
+  export const inboundSchema = ReadEvent3Event$inboundSchema;
+  /** @deprecated use `ReadEvent3Event$outboundSchema` instead. */
+  export const outboundSchema = ReadEvent3Event$outboundSchema;
+}
+
 /** @internal */
 export const ErrorT$inboundSchema: z.ZodType<ErrorT, z.ZodTypeDef, unknown> = z
   .object({
     data: z.string(),
-    event: z.string(),
+    event: ReadEvent3Event$inboundSchema,
   });
 
 /** @internal */
@@ -97,7 +188,7 @@ export const ErrorT$outboundSchema: z.ZodType<
   ErrorT
 > = z.object({
   data: z.string(),
-  event: z.string(),
+  event: ReadEvent3Event$outboundSchema,
 });
 
 /**
@@ -127,6 +218,110 @@ export function errorFromJSON(
   );
 }
 
+/** @internal */
+export const ReadEventEvent$inboundSchema: z.ZodNativeEnum<
+  typeof ReadEventEvent
+> = z.nativeEnum(ReadEventEvent);
+
+/** @internal */
+export const ReadEventEvent$outboundSchema: z.ZodNativeEnum<
+  typeof ReadEventEvent
+> = ReadEventEvent$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ReadEventEvent$ {
+  /** @deprecated use `ReadEventEvent$inboundSchema` instead. */
+  export const inboundSchema = ReadEventEvent$inboundSchema;
+  /** @deprecated use `ReadEventEvent$outboundSchema` instead. */
+  export const outboundSchema = ReadEventEvent$outboundSchema;
+}
+
+/** @internal */
+export const ReadEvent2$inboundSchema: z.ZodType<
+  ReadEvent2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `malformed json: ${err}`,
+      });
+      return z.NEVER;
+    }
+  }).pipe(TailResponse$inboundSchema),
+  event: ReadEventEvent$inboundSchema,
+});
+
+/** @internal */
+export type ReadEvent2$Outbound = {
+  data: TailResponse$Outbound;
+  event: string;
+};
+
+/** @internal */
+export const ReadEvent2$outboundSchema: z.ZodType<
+  ReadEvent2$Outbound,
+  z.ZodTypeDef,
+  ReadEvent2
+> = z.object({
+  data: TailResponse$outboundSchema,
+  event: ReadEventEvent$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ReadEvent2$ {
+  /** @deprecated use `ReadEvent2$inboundSchema` instead. */
+  export const inboundSchema = ReadEvent2$inboundSchema;
+  /** @deprecated use `ReadEvent2$outboundSchema` instead. */
+  export const outboundSchema = ReadEvent2$outboundSchema;
+  /** @deprecated use `ReadEvent2$Outbound` instead. */
+  export type Outbound = ReadEvent2$Outbound;
+}
+
+export function readEvent2ToJSON(readEvent2: ReadEvent2): string {
+  return JSON.stringify(ReadEvent2$outboundSchema.parse(readEvent2));
+}
+
+export function readEvent2FromJSON(
+  jsonString: string,
+): SafeParseResult<ReadEvent2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ReadEvent2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ReadEvent2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Event$inboundSchema: z.ZodNativeEnum<typeof Event> = z.nativeEnum(
+  Event,
+);
+
+/** @internal */
+export const Event$outboundSchema: z.ZodNativeEnum<typeof Event> =
+  Event$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Event$ {
+  /** @deprecated use `Event$inboundSchema` instead. */
+  export const inboundSchema = Event$inboundSchema;
+  /** @deprecated use `Event$outboundSchema` instead. */
+  export const outboundSchema = Event$outboundSchema;
+}
+
 /** @internal */
 export const Batch$inboundSchema: z.ZodType<Batch, z.ZodTypeDef, unknown> = z
   .object({
@@ -141,13 +336,15 @@ export const Batch$inboundSchema: z.ZodType<Batch, z.ZodTypeDef, unknown> = z
         return z.NEVER;
       }
     }).pipe(ReadBatch$inboundSchema),
-    event: z.string(),
+    event: Event$inboundSchema,
+    id: z.string(),
   });
 
 /** @internal */
 export type Batch$Outbound = {
   data: ReadBatch$Outbound;
   event: string;
+  id: string;
 };
 
 /** @internal */
@@ -157,7 +354,8 @@ export const Batch$outboundSchema: z.ZodType<
   Batch
 > = z.object({
   data: ReadBatch$outboundSchema,
-  event: z.string(),
+  event: Event$outboundSchema,
+  id: z.string(),
 });
 
 /**
@@ -193,16 +391,18 @@ export const ReadEvent$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => Batch$inboundSchema),
+  z.lazy(() => ReadEvent2$inboundSchema),
   z.lazy(() => ErrorT$inboundSchema),
   z.lazy(() => Ping$inboundSchema),
+  z.lazy(() => Batch$inboundSchema),
 ]);
 
 /** @internal */
 export type ReadEvent$Outbound =
-  | Batch$Outbound
+  | ReadEvent2$Outbound
   | ErrorT$Outbound
-  | Ping$Outbound;
+  | Ping$Outbound
+  | Batch$Outbound;
 
 /** @internal */
 export const ReadEvent$outboundSchema: z.ZodType<
@@ -210,9 +410,10 @@ export const ReadEvent$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReadEvent
 > = z.union([
-  z.lazy(() => Batch$outboundSchema),
+  z.lazy(() => ReadEvent2$outboundSchema),
   z.lazy(() => ErrorT$outboundSchema),
   z.lazy(() => Ping$outboundSchema),
+  z.lazy(() => Batch$outboundSchema),
 ]);
 
 /**

package/src/models/components/s2format.ts

@@ -6,8 +6,8 @@ import * as z from "zod";
 import { ClosedEnum } from "../../types/enums.js";
 
 export const S2Format = {
-  Json: "json",
-  JsonBinsafe: "json-binsafe",
+  Raw: "raw",
+  Base64: "base64",
 } as const;
 export type S2Format = ClosedEnum<typeof S2Format>;
 

package/src/models/components/scalar.ts

@@ -0,0 +1,78 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  MetricUnit,
+  MetricUnit$inboundSchema,
+  MetricUnit$outboundSchema,
+} from "./metricunit.js";
+
+export type Scalar = {
+  /**
+   * Metric name.
+   */
+  name: string;
+  unit: MetricUnit;
+  /**
+   * Metric value.
+   */
+  value: number;
+};
+
+/** @internal */
+export const Scalar$inboundSchema: z.ZodType<Scalar, z.ZodTypeDef, unknown> = z
+  .object({
+    name: z.string(),
+    unit: MetricUnit$inboundSchema,
+    value: z.number(),
+  });
+
+/** @internal */
+export type Scalar$Outbound = {
+  name: string;
+  unit: string;
+  value: number;
+};
+
+/** @internal */
+export const Scalar$outboundSchema: z.ZodType<
+  Scalar$Outbound,
+  z.ZodTypeDef,
+  Scalar
+> = z.object({
+  name: z.string(),
+  unit: MetricUnit$outboundSchema,
+  value: z.number(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Scalar$ {
+  /** @deprecated use `Scalar$inboundSchema` instead. */
+  export const inboundSchema = Scalar$inboundSchema;
+  /** @deprecated use `Scalar$outboundSchema` instead. */
+  export const outboundSchema = Scalar$outboundSchema;
+  /** @deprecated use `Scalar$Outbound` instead. */
+  export type Outbound = Scalar$Outbound;
+}
+
+export function scalarToJSON(scalar: Scalar): string {
+  return JSON.stringify(Scalar$outboundSchema.parse(scalar));
+}
+
+export function scalarFromJSON(
+  jsonString: string,
+): SafeParseResult<Scalar, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Scalar$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Scalar' from JSON`,
+  );
+}

package/src/models/components/timeseriesinterval.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const TimeseriesInterval = {
+  Minute: "minute",
+  Hour: "hour",
+  Day: "day",
+} as const;
+export type TimeseriesInterval = ClosedEnum<typeof TimeseriesInterval>;
+
+/** @internal */
+export const TimeseriesInterval$inboundSchema: z.ZodNativeEnum<
+  typeof TimeseriesInterval
+> = z.nativeEnum(TimeseriesInterval);
+
+/** @internal */
+export const TimeseriesInterval$outboundSchema: z.ZodNativeEnum<
+  typeof TimeseriesInterval
+> = TimeseriesInterval$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TimeseriesInterval$ {
+  /** @deprecated use `TimeseriesInterval$inboundSchema` instead. */
+  export const inboundSchema = TimeseriesInterval$inboundSchema;
+  /** @deprecated use `TimeseriesInterval$outboundSchema` instead. */
+  export const outboundSchema = TimeseriesInterval$outboundSchema;
+}

package/src/models/errors/appendconditionfailed.ts

@@ -59,14 +59,14 @@ export class SeqNum extends Error {
  * Fencing token did not match.
  *
  * @remarks
- * The expected fencing token is returned, encoded with base64.
+ * The expected fencing token is returned.
  */
 export type FencingTokenData = {
   /**
    * Fencing token did not match.
    *
    * @remarks
-   * The expected fencing token is returned, encoded with base64.
+   * The expected fencing token is returned.
    */
   fencingTokenMismatch: string;
 };
@@ -75,14 +75,14 @@ export type FencingTokenData = {
  * Fencing token did not match.
  *
  * @remarks
- * The expected fencing token is returned, encoded with base64.
+ * The expected fencing token is returned.
  */
 export class FencingToken extends Error {
   /**
    * Fencing token did not match.
    *
    * @remarks
-   * The expected fencing token is returned, encoded with base64.
+   * The expected fencing token is returned.
    */
   fencingTokenMismatch: string;
 

package/src/models/operations/accountmetrics.ts

@@ -0,0 +1,91 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AccountMetricsRequest = {
+  /**
+   * Metric type to return.
+   */
+  set: components.AccountMetricSet;
+  /**
+   * Start timestamp, in Unix epoch seconds, if applicable for metric set.
+   */
+  start?: number | undefined;
+  /**
+   * End timestamp, in Unix epoch seconds, if applicable for metric set.
+   */
+  end?: number | undefined;
+  /**
+   * For timeseries metric sets, the interval to aggregate over.
+   */
+  interval?: components.TimeseriesInterval | undefined;
+};
+
+/** @internal */
+export const AccountMetricsRequest$inboundSchema: z.ZodType<
+  AccountMetricsRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  set: components.AccountMetricSet$inboundSchema,
+  start: z.number().int().optional(),
+  end: z.number().int().optional(),
+  interval: components.TimeseriesInterval$inboundSchema.optional(),
+});
+
+/** @internal */
+export type AccountMetricsRequest$Outbound = {
+  set: string;
+  start?: number | undefined;
+  end?: number | undefined;
+  interval?: string | undefined;
+};
+
+/** @internal */
+export const AccountMetricsRequest$outboundSchema: z.ZodType<
+  AccountMetricsRequest$Outbound,
+  z.ZodTypeDef,
+  AccountMetricsRequest
+> = z.object({
+  set: components.AccountMetricSet$outboundSchema,
+  start: z.number().int().optional(),
+  end: z.number().int().optional(),
+  interval: components.TimeseriesInterval$outboundSchema.optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountMetricsRequest$ {
+  /** @deprecated use `AccountMetricsRequest$inboundSchema` instead. */
+  export const inboundSchema = AccountMetricsRequest$inboundSchema;
+  /** @deprecated use `AccountMetricsRequest$outboundSchema` instead. */
+  export const outboundSchema = AccountMetricsRequest$outboundSchema;
+  /** @deprecated use `AccountMetricsRequest$Outbound` instead. */
+  export type Outbound = AccountMetricsRequest$Outbound;
+}
+
+export function accountMetricsRequestToJSON(
+  accountMetricsRequest: AccountMetricsRequest,
+): string {
+  return JSON.stringify(
+    AccountMetricsRequest$outboundSchema.parse(accountMetricsRequest),
+  );
+}
+
+export function accountMetricsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountMetricsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountMetricsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountMetricsRequest' from JSON`,
+  );
+}

package/src/models/operations/append.ts

@@ -18,18 +18,14 @@ export const AppendServerList = [
 
 export type AppendRequest = {
   /**
-   * Stream name, which must be unique within the basin.
-   *
-   * @remarks
-   * It can be an arbitrary string up to 512 characters.
+   * Stream name.
    */
   stream: string;
   /**
-   * Recognized when the Content-Type is `application/json`.
+   * Define treatment of blob fields when exchanging records as JSON.
    *
    * @remarks
-   * json: UTF-8 data
-   * json-binsafe: Base64-encoded binary data
+   * The default is `raw`.
    */
   s2Format?: components.S2Format | undefined;
   /**