@steamsets/client-ts 0.34.2 → 0.34.4

package/src/funcs/statsSubscribe.ts

@@ -0,0 +1,168 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { SteamSetsCore } from "../core.js";
+import { matchStatusCode } from "../lib/http.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import { SteamSetsError } from "../models/errors/steamsetserror.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+
+export enum SubscribeAcceptEnum {
+  applicationProblemPlusJson = "application/problem+json",
+  textEventStream = "text/event-stream",
+}
+
+/**
+ * Server-sent-events stream of platform stats. Emits a snapshot, then deltas as the queues commit them.
+ */
+export function statsSubscribe(
+  client: SteamSetsCore,
+  options?: RequestOptions & { acceptHeaderOverride?: SubscribeAcceptEnum },
+): APIPromise<
+  Result<
+    operations.StatsSubscribeResponse,
+    | SteamSetsError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    options,
+  ));
+}
+
+async function $do(
+  client: SteamSetsCore,
+  options?: RequestOptions & { acceptHeaderOverride?: SubscribeAcceptEnum },
+): Promise<
+  [
+    Result<
+      operations.StatsSubscribeResponse,
+      | SteamSetsError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const path = pathToFunc("/v1/stats.subscribe")();
+
+  const headers = new Headers(compactMap({
+    Accept: options?.acceptHeaderOverride
+      || "application/problem+json;q=1, text/event-stream;q=0",
+  }));
+
+  const secConfig = await extractSecurity(client._options.token);
+  const securityInput = secConfig == null ? {} : { token: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "stats.subscribe",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.token,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 500,
+          maxInterval: 5000,
+          exponent: 1.5,
+          maxElapsedTime: 60000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    uaHeader: "x-speakeasy-user-agent",
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode: number) =>
+      matchStatusCode({ status: statusCode } as Response, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req },
+  };
+
+  const [result] = await M.match<
+    operations.StatsSubscribeResponse,
+    | SteamSetsError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.sse(200, operations.StatsSubscribeResponse$inboundSchema, {
+      key: "Server Sent Events",
+    }),
+    M.fail("4XX"),
+    M.fail("5XX"),
+    M.json("default", operations.StatsSubscribeResponse$inboundSchema, {
+      ctype: "application/problem+json",
+      key: "ErrorModel",
+    }),
+  )(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -59,8 +59,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.34.2",
-  genVersion: "2.881.17",
+  sdkVersion: "0.34.4",
+  genVersion: "2.882.0",
   userAgent:
-    "speakeasy-sdk/typescript 0.34.2 2.881.17 1.0.0 @steamsets/client-ts",
+    "speakeasy-sdk/typescript 0.34.4 2.882.0 1.0.0 @steamsets/client-ts",
 } as const;

package/src/models/components/eventaccountupdateddata.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EventAccountUpdatedData = {
+  accountId: number;
+  status: string;
+};
+
+/** @internal */
+export const EventAccountUpdatedData$inboundSchema: z.ZodType<
+  EventAccountUpdatedData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accountId: z.number().int(),
+  status: z.string(),
+});
+
+export function eventAccountUpdatedDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EventAccountUpdatedData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventAccountUpdatedData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventAccountUpdatedData' from JSON`,
+  );
+}

package/src/models/components/eventaccountviewtickdata.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EventAccountViewTickData = {
+  accountId: number;
+  totalDelta: number;
+};
+
+/** @internal */
+export const EventAccountViewTickData$inboundSchema: z.ZodType<
+  EventAccountViewTickData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accountId: z.number().int(),
+  totalDelta: z.number().int(),
+});
+
+export function eventAccountViewTickDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EventAccountViewTickData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventAccountViewTickData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventAccountViewTickData' from JSON`,
+  );
+}

package/src/models/components/eventstatsheartbeatdata.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EventStatsHeartbeatData = {
+  heartbeat: number;
+};
+
+/** @internal */
+export const EventStatsHeartbeatData$inboundSchema: z.ZodType<
+  EventStatsHeartbeatData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  heartbeat: z.number().int(),
+});
+
+export function eventStatsHeartbeatDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EventStatsHeartbeatData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventStatsHeartbeatData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventStatsHeartbeatData' from JSON`,
+  );
+}

package/src/models/components/eventstatsupdateddata.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EventStatsUpdatedData = {
+  date: string;
+  deltas: { [k: string]: number };
+};
+
+/** @internal */
+export const EventStatsUpdatedData$inboundSchema: z.ZodType<
+  EventStatsUpdatedData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  date: z.string(),
+  deltas: z.record(z.number().int()),
+});
+
+export function eventStatsUpdatedDataFromJSON(
+  jsonString: string,
+): SafeParseResult<EventStatsUpdatedData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventStatsUpdatedData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventStatsUpdatedData' from JSON`,
+  );
+}

package/src/models/components/heartbeat.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type Heartbeat = {
+  heartbeat: number;
+};
+
+/** @internal */
+export const Heartbeat$inboundSchema: z.ZodType<
+  Heartbeat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  heartbeat: z.number().int(),
+});
+
+export function heartbeatFromJSON(
+  jsonString: string,
+): SafeParseResult<Heartbeat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Heartbeat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Heartbeat' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -41,10 +41,15 @@ export * from "./developerappanalyticstimeseries.js";
 export * from "./developerappanalyticstimeseriespoint.js";
 export * from "./errordetail.js";
 export * from "./errormodel.js";
+export * from "./eventaccountupdateddata.js";
+export * from "./eventaccountviewtickdata.js";
 export * from "./eventmarketpricetickdata.js";
+export * from "./eventstatsheartbeatdata.js";
+export * from "./eventstatsupdateddata.js";
 export * from "./findownersrequestbody.js";
 export * from "./findownersresponsebody.js";
 export * from "./friendpath.js";
+export * from "./heartbeat.js";
 export * from "./historyvalue.js";
 export * from "./httpmetadata.js";
 export * from "./idsearch.js";

package/src/models/operations/accountsubscribe.ts

@@ -0,0 +1,251 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { EventStream } from "../../lib/event-streams.js";
+import { remap as remap$ } from "../../lib/primitives.js";
+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 AccountSubscribeRequest = {
+  /**
+   * Account ID to subscribe to
+   */
+  accountId: number;
+};
+
+export type EventHeartbeat = {
+  data: components.Heartbeat;
+  /**
+   * The event name.
+   */
+  event: "heartbeat";
+  /**
+   * The event ID.
+   */
+  id?: string | undefined;
+  /**
+   * The retry time in milliseconds.
+   */
+  retry?: number | undefined;
+};
+
+export type EventAccountViewTick = {
+  data: components.EventAccountViewTickData;
+  /**
+   * The event name.
+   */
+  event: "account-view-tick";
+  /**
+   * The event ID.
+   */
+  id?: string | undefined;
+  /**
+   * The retry time in milliseconds.
+   */
+  retry?: number | undefined;
+};
+
+export type EventAccountUpdated = {
+  data: components.EventAccountUpdatedData;
+  /**
+   * The event name.
+   */
+  event: "account-updated";
+  /**
+   * The event ID.
+   */
+  id?: string | undefined;
+  /**
+   * The retry time in milliseconds.
+   */
+  retry?: number | undefined;
+};
+
+/**
+ * Each oneOf object in the array represents one possible Server Sent Events (SSE) message, serialized as UTF-8 text according to the SSE specification.
+ */
+export type AccountSubscribeServerSentEvents =
+  | EventAccountUpdated
+  | EventAccountViewTick
+  | EventHeartbeat;
+
+export type AccountSubscribeResponse = {
+  httpMeta: components.HTTPMetadata;
+  /**
+   * OK
+   */
+  serverSentEvents?:
+    | EventStream<EventAccountUpdated | EventAccountViewTick | EventHeartbeat>
+    | undefined;
+};
+
+/** @internal */
+export type AccountSubscribeRequest$Outbound = {
+  accountId: number;
+};
+
+/** @internal */
+export const AccountSubscribeRequest$outboundSchema: z.ZodType<
+  AccountSubscribeRequest$Outbound,
+  z.ZodTypeDef,
+  AccountSubscribeRequest
+> = z.object({
+  accountId: z.number().int(),
+});
+
+export function accountSubscribeRequestToJSON(
+  accountSubscribeRequest: AccountSubscribeRequest,
+): string {
+  return JSON.stringify(
+    AccountSubscribeRequest$outboundSchema.parse(accountSubscribeRequest),
+  );
+}
+
+/** @internal */
+export const EventHeartbeat$inboundSchema: z.ZodType<
+  EventHeartbeat,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(components.Heartbeat$inboundSchema),
+  event: z.literal("heartbeat"),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
+
+export function eventHeartbeatFromJSON(
+  jsonString: string,
+): SafeParseResult<EventHeartbeat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventHeartbeat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventHeartbeat' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventAccountViewTick$inboundSchema: z.ZodType<
+  EventAccountViewTick,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(components.EventAccountViewTickData$inboundSchema),
+  event: z.literal("account-view-tick"),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
+
+export function eventAccountViewTickFromJSON(
+  jsonString: string,
+): SafeParseResult<EventAccountViewTick, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventAccountViewTick$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventAccountViewTick' from JSON`,
+  );
+}
+
+/** @internal */
+export const EventAccountUpdated$inboundSchema: z.ZodType<
+  EventAccountUpdated,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(components.EventAccountUpdatedData$inboundSchema),
+  event: z.literal("account-updated"),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
+
+export function eventAccountUpdatedFromJSON(
+  jsonString: string,
+): SafeParseResult<EventAccountUpdated, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EventAccountUpdated$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EventAccountUpdated' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountSubscribeServerSentEvents$inboundSchema: z.ZodType<
+  AccountSubscribeServerSentEvents,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => EventAccountUpdated$inboundSchema),
+  z.lazy(() => EventAccountViewTick$inboundSchema),
+  z.lazy(() => EventHeartbeat$inboundSchema),
+]);
+
+export function accountSubscribeServerSentEventsFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountSubscribeServerSentEvents, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountSubscribeServerSentEvents$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountSubscribeServerSentEvents' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountSubscribeResponse$inboundSchema: z.ZodType<
+  AccountSubscribeResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  "Server Sent Events": z.instanceof(ReadableStream<Uint8Array>)
+    .transform(stream => {
+      return new EventStream(stream, rawEvent => {
+        return {
+          done: false,
+          value: z.union([
+            z.lazy(() => EventAccountUpdated$inboundSchema),
+            z.lazy(() => EventAccountViewTick$inboundSchema),
+            z.lazy(() => EventHeartbeat$inboundSchema),
+          ]).parse(rawEvent),
+        };
+      });
+    }).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "Server Sent Events": "serverSentEvents",
+  });
+});
+
+export function accountSubscribeResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountSubscribeResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountSubscribeResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountSubscribeResponse' from JSON`,
+  );
+}

package/src/models/operations/badgepricingsubscribe.ts

@@ -26,7 +26,7 @@ export type EventMarketPriceTick = {
   retry?: number | undefined;
 };
 
-export type EventHeartbeat = {
+export type ServerSentEventsEventHeartbeat = {
   data: components.PricingHeartbeat;
   /**
    * The event name.
@@ -46,7 +46,7 @@ export type EventHeartbeat = {
  * Each oneOf object in the array represents one possible Server Sent Events (SSE) message, serialized as UTF-8 text according to the SSE specification.
  */
 export type BadgePricingSubscribeServerSentEvents =
-  | EventHeartbeat
+  | ServerSentEventsEventHeartbeat
   | EventMarketPriceTick;
 
 export type BadgePricingSubscribeResponse = {
@@ -55,7 +55,7 @@ export type BadgePricingSubscribeResponse = {
    * OK
    */
   serverSentEvents?:
-    | EventStream<EventHeartbeat | EventMarketPriceTick>
+    | EventStream<ServerSentEventsEventHeartbeat | EventMarketPriceTick>
     | undefined;
   /**
    * Error
@@ -93,8 +93,8 @@ export function eventMarketPriceTickFromJSON(
 }
 
 /** @internal */
-export const EventHeartbeat$inboundSchema: z.ZodType<
-  EventHeartbeat,
+export const ServerSentEventsEventHeartbeat$inboundSchema: z.ZodType<
+  ServerSentEventsEventHeartbeat,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -111,13 +111,13 @@ export const EventHeartbeat$inboundSchema: z.ZodType<
   retry: z.number().int().optional(),
 });
 
-export function eventHeartbeatFromJSON(
+export function serverSentEventsEventHeartbeatFromJSON(
   jsonString: string,
-): SafeParseResult<EventHeartbeat, SDKValidationError> {
+): SafeParseResult<ServerSentEventsEventHeartbeat, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => EventHeartbeat$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EventHeartbeat' from JSON`,
+    (x) => ServerSentEventsEventHeartbeat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ServerSentEventsEventHeartbeat' from JSON`,
   );
 }
 
@@ -127,7 +127,7 @@ export const BadgePricingSubscribeServerSentEvents$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => EventHeartbeat$inboundSchema),
+  z.lazy(() => ServerSentEventsEventHeartbeat$inboundSchema),
   z.lazy(() => EventMarketPriceTick$inboundSchema),
 ]);
 
@@ -155,7 +155,7 @@ export const BadgePricingSubscribeResponse$inboundSchema: z.ZodType<
         return {
           done: false,
           value: z.union([
-            z.lazy(() => EventHeartbeat$inboundSchema),
+            z.lazy(() => ServerSentEventsEventHeartbeat$inboundSchema),
             z.lazy(() => EventMarketPriceTick$inboundSchema),
           ]).parse(rawEvent),
         };