@steamsets/client-ts 0.13.5 → 0.14.0

package/src/funcs/publicGetFriends.ts

@@ -75,14 +75,14 @@ export async function publicGetFriends(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/publicGetInfo.ts

@@ -75,14 +75,14 @@ export async function publicGetInfo(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/publicGetLeaderboardHistory.ts

@@ -75,14 +75,14 @@ export async function publicGetLeaderboardHistory(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/sessionCreate.ts

@@ -91,14 +91,14 @@ export async function sessionCreate(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/sessionLogin.ts

@@ -84,14 +84,14 @@ export async function sessionLogin(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/sessionsDelete.ts

@@ -76,14 +76,14 @@ export async function sessionsDelete(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/sessionsGet.ts

@@ -59,14 +59,14 @@ export async function sessionsGet(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/settingsGet.ts

@@ -59,14 +59,14 @@ export async function settingsGet(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/settingsSendEmailVerification.ts

@@ -80,14 +80,14 @@ export async function settingsSendEmailVerification(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/settingsUpdate.ts

@@ -82,14 +82,14 @@ export async function settingsUpdate(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/funcs/settingsVerifyEmail.ts

@@ -75,14 +75,14 @@ export async function settingsVerifyEmail(
         strategy: "backoff",
         backoff: {
           initialInterval: 500,
-          maxInterval: 60000,
+          maxInterval: 5000,
           exponent: 1.5,
-          maxElapsedTime: 3600000,
+          maxElapsedTime: 60000,
         },
         retryConnectionErrors: true,
       }
       || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["500", "501", "502", "503", "504"],
+    retryCodes: options?.retryCodes || ["501", "502", "503", "504"],
   };
 
   const requestRes = client._createRequest(context, {

package/src/hooks/hooks.ts

@@ -12,6 +12,7 @@ import {
   BeforeCreateRequestHook,
   BeforeRequestContext,
   BeforeRequestHook,
+  Hook,
   Hooks,
   SDKInitHook,
   SDKInitOptions,
@@ -25,6 +26,25 @@ export class SDKHooks implements Hooks {
   afterErrorHooks: AfterErrorHook[] = [];
 
   constructor() {
+    const presetHooks: Array<Hook> = [];
+
+    for (const hook of presetHooks) {
+      if ("sdkInit" in hook) {
+        this.registerSDKInitHook(hook);
+      }
+      if ("beforeCreateRequest" in hook) {
+        this.registerBeforeCreateRequestHook(hook);
+      }
+      if ("beforeRequest" in hook) {
+        this.registerBeforeRequestHook(hook);
+      }
+      if ("afterSuccess" in hook) {
+        this.registerAfterSuccessHook(hook);
+      }
+      if ("afterError" in hook) {
+        this.registerAfterErrorHook(hook);
+      }
+    }
   }
 
   registerSDKInitHook(hook: SDKInitHook) {

package/src/hooks/types.ts

@@ -100,3 +100,10 @@ export interface Hooks {
   /** Registers a hook to be used by the SDK for the after error event. */
   registerAfterErrorHook(hook: AfterErrorHook): void;
 }
+
+export type Hook =
+  | SDKInitHook
+  | BeforeCreateRequestHook
+  | BeforeRequestHook
+  | AfterSuccessHook
+  | AfterErrorHook;

package/src/lib/config.ts

@@ -55,8 +55,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.0.0",
-  sdkVersion: "0.13.5",
-  genVersion: "2.461.2",
+  sdkVersion: "0.14.0",
+  genVersion: "2.474.6",
   userAgent:
-    "speakeasy-sdk/typescript 0.13.5 2.461.2 1.0.0 @steamsets/client-ts",
+    "speakeasy-sdk/typescript 0.14.0 2.474.6 1.0.0 @steamsets/client-ts",
 } as const;

package/src/lib/primitives.ts

@@ -58,3 +58,65 @@ export function remap<
 
   return out;
 }
+
+export function combineSignals(
+  ...signals: Array<AbortSignal | null | undefined>
+): AbortSignal | null {
+  const filtered: AbortSignal[] = [];
+  for (const signal of signals) {
+    if (signal) {
+      filtered.push(signal);
+    }
+  }
+
+  switch (filtered.length) {
+    case 0:
+    case 1:
+      return filtered[0] || null;
+    default:
+      if ("any" in AbortSignal && typeof AbortSignal.any === "function") {
+        return AbortSignal.any(filtered);
+      }
+      return abortSignalAny(filtered);
+  }
+}
+
+export function abortSignalAny(signals: AbortSignal[]): AbortSignal {
+  const controller = new AbortController();
+  const result = controller.signal;
+  if (!signals.length) {
+    return controller.signal;
+  }
+
+  if (signals.length === 1) {
+    return signals[0] || controller.signal;
+  }
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal;
+    }
+  }
+
+  function abort(this: AbortSignal) {
+    controller.abort(this.reason);
+    clean();
+  }
+
+  const signalRefs: WeakRef<AbortSignal>[] = [];
+  function clean() {
+    for (const signalRef of signalRefs) {
+      const signal = signalRef.deref();
+      if (signal) {
+        signal.removeEventListener("abort", abort);
+      }
+    }
+  }
+
+  for (const signal of signals) {
+    signalRefs.push(new WeakRef(signal));
+    signal.addEventListener("abort", abort);
+  }
+
+  return result;
+}

package/src/models/components/index.ts

@@ -16,7 +16,6 @@ export * from "./connection.js";
 export * from "./country.js";
 export * from "./designtag.js";
 export * from "./developerapp.js";
-export * from "./emailnotification.js";
 export * from "./errordetail.js";
 export * from "./httpmetadata.js";
 export * from "./idstruct.js";
@@ -35,6 +34,11 @@ export * from "./session.js";
 export * from "./setdesigntag.js";
 export * from "./state.js";
 export * from "./v1accountapp.js";
+export * from "./v1accountbadgebookmark.js";
+export * from "./v1accountbadgebookmarkrequestbody.js";
+export * from "./v1accountbadgebookmarkresponsebody.js";
+export * from "./v1accountbadgebookmarksrequestbody.js";
+export * from "./v1accountbadgebookmarksresponsebody.js";
 export * from "./v1accountdatapointsresponsebody.js";
 export * from "./v1accountdeveloperappdeleterequestbody.js";
 export * from "./v1accountdeveloperappdeleteresponsebody.js";
@@ -48,18 +52,20 @@ export * from "./v1accountleaderboardbadgesearch.js";
 export * from "./v1accountleaderboardhistoryresponsebody.js";
 export * from "./v1accountleaderboardrequestbody.js";
 export * from "./v1accountleaderboardresponsebody.js";
+export * from "./v1accountlocationupdate.js";
 export * from "./v1accountmetaresponsebody.js";
+export * from "./v1accountnameupdate.js";
 export * from "./v1accountplaytimedatapoint.js";
 export * from "./v1accountqueuerequestbody.js";
 export * from "./v1accountsappsresponsebody.js";
+export * from "./v1admingetaccountresponsebody.js";
 export * from "./v1admingeteventsresponsebody.js";
+export * from "./v1adminupdateeventrequestbody.js";
 export * from "./v1adminupdateeventresponsebody.js";
 export * from "./v1adminupdateresourcesrequestbody.js";
 export * from "./v1adminupdaterolessrequestbody.js";
 export * from "./v1appbadge.js";
-export * from "./v1badgebookmark.js";
-export * from "./v1badgebookmarkrequestbody.js";
-export * from "./v1badgebookmarkresponsebody.js";
+export * from "./v1appeventmapping.js";
 export * from "./v1badgesresponsebody.js";
 export * from "./v1badgetagrequestbody.js";
 export * from "./v1badgetagresponsebody.js";
@@ -77,8 +83,7 @@ export * from "./v1deletesessionresponsebody.js";
 export * from "./v1developerappcreaterequestbody.js";
 export * from "./v1developerappcreateresponsebody.js";
 export * from "./v1event.js";
-export * from "./v1getbadgebookmarksrequestbody.js";
-export * from "./v1getbadgebookmarksresponsebody.js";
+export * from "./v1getimagesresponsebody.js";
 export * from "./v1getsessionbody.js";
 export * from "./v1getsettingsbody.js";
 export * from "./v1groupleaderboardgroup.js";
@@ -95,6 +100,7 @@ export * from "./v1livenessresponsebody.js";
 export * from "./v1loginresponsebody.js";
 export * from "./v1updateconnectionrequestbody.js";
 export * from "./v1updateconnectionresponsebody.js";
+export * from "./v1updateimage.js";
 export * from "./v1updateimagerequestbody.js";
 export * from "./v1updateimageresponsebody.js";
 export * from "./v1updatesettingsrequestbody.js";

package/src/models/components/v1accountbadgebookmark.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";
+
+export type V1AccountBadgeBookmark = {
+  /**
+   * The badge id
+   */
+  badgeId: string;
+  /**
+   * The time the badge was bookmarked
+   */
+  bookmarkedAt: Date;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmark$inboundSchema: z.ZodType<
+  V1AccountBadgeBookmark,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  badgeId: z.string(),
+  bookmarkedAt: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+});
+
+/** @internal */
+export type V1AccountBadgeBookmark$Outbound = {
+  badgeId: string;
+  bookmarkedAt: string;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmark$outboundSchema: z.ZodType<
+  V1AccountBadgeBookmark$Outbound,
+  z.ZodTypeDef,
+  V1AccountBadgeBookmark
+> = z.object({
+  badgeId: z.string(),
+  bookmarkedAt: z.date().transform(v => v.toISOString()),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountBadgeBookmark$ {
+  /** @deprecated use `V1AccountBadgeBookmark$inboundSchema` instead. */
+  export const inboundSchema = V1AccountBadgeBookmark$inboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmark$outboundSchema` instead. */
+  export const outboundSchema = V1AccountBadgeBookmark$outboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmark$Outbound` instead. */
+  export type Outbound = V1AccountBadgeBookmark$Outbound;
+}
+
+export function v1AccountBadgeBookmarkToJSON(
+  v1AccountBadgeBookmark: V1AccountBadgeBookmark,
+): string {
+  return JSON.stringify(
+    V1AccountBadgeBookmark$outboundSchema.parse(v1AccountBadgeBookmark),
+  );
+}
+
+export function v1AccountBadgeBookmarkFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountBadgeBookmark, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1AccountBadgeBookmark$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountBadgeBookmark' from JSON`,
+  );
+}

package/src/models/components/v1accountbadgebookmarkrequestbody.ts

@@ -0,0 +1,79 @@
+/*
+ * 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";
+
+export type V1AccountBadgeBookmarkRequestBody = {
+  /**
+   * The badge id
+   */
+  badgeId: string;
+  /**
+   * Whether to bookmark or unbookmark the badge
+   */
+  bookmark: boolean;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmarkRequestBody$inboundSchema: z.ZodType<
+  V1AccountBadgeBookmarkRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  badgeId: z.string(),
+  bookmark: z.boolean(),
+});
+
+/** @internal */
+export type V1AccountBadgeBookmarkRequestBody$Outbound = {
+  badgeId: string;
+  bookmark: boolean;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmarkRequestBody$outboundSchema: z.ZodType<
+  V1AccountBadgeBookmarkRequestBody$Outbound,
+  z.ZodTypeDef,
+  V1AccountBadgeBookmarkRequestBody
+> = z.object({
+  badgeId: z.string(),
+  bookmark: z.boolean(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountBadgeBookmarkRequestBody$ {
+  /** @deprecated use `V1AccountBadgeBookmarkRequestBody$inboundSchema` instead. */
+  export const inboundSchema = V1AccountBadgeBookmarkRequestBody$inboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarkRequestBody$outboundSchema` instead. */
+  export const outboundSchema =
+    V1AccountBadgeBookmarkRequestBody$outboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarkRequestBody$Outbound` instead. */
+  export type Outbound = V1AccountBadgeBookmarkRequestBody$Outbound;
+}
+
+export function v1AccountBadgeBookmarkRequestBodyToJSON(
+  v1AccountBadgeBookmarkRequestBody: V1AccountBadgeBookmarkRequestBody,
+): string {
+  return JSON.stringify(
+    V1AccountBadgeBookmarkRequestBody$outboundSchema.parse(
+      v1AccountBadgeBookmarkRequestBody,
+    ),
+  );
+}
+
+export function v1AccountBadgeBookmarkRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountBadgeBookmarkRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1AccountBadgeBookmarkRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountBadgeBookmarkRequestBody' from JSON`,
+  );
+}

package/src/models/components/v1accountbadgebookmarkresponsebody.ts

@@ -0,0 +1,82 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type V1AccountBadgeBookmarkResponseBody = {
+  /**
+   * A URL to the JSON Schema for this object.
+   */
+  dollarSchema?: string | undefined;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmarkResponseBody$inboundSchema: z.ZodType<
+  V1AccountBadgeBookmarkResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  $schema: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "$schema": "dollarSchema",
+  });
+});
+
+/** @internal */
+export type V1AccountBadgeBookmarkResponseBody$Outbound = {
+  $schema?: string | undefined;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmarkResponseBody$outboundSchema: z.ZodType<
+  V1AccountBadgeBookmarkResponseBody$Outbound,
+  z.ZodTypeDef,
+  V1AccountBadgeBookmarkResponseBody
+> = z.object({
+  dollarSchema: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    dollarSchema: "$schema",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountBadgeBookmarkResponseBody$ {
+  /** @deprecated use `V1AccountBadgeBookmarkResponseBody$inboundSchema` instead. */
+  export const inboundSchema = V1AccountBadgeBookmarkResponseBody$inboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarkResponseBody$outboundSchema` instead. */
+  export const outboundSchema =
+    V1AccountBadgeBookmarkResponseBody$outboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarkResponseBody$Outbound` instead. */
+  export type Outbound = V1AccountBadgeBookmarkResponseBody$Outbound;
+}
+
+export function v1AccountBadgeBookmarkResponseBodyToJSON(
+  v1AccountBadgeBookmarkResponseBody: V1AccountBadgeBookmarkResponseBody,
+): string {
+  return JSON.stringify(
+    V1AccountBadgeBookmarkResponseBody$outboundSchema.parse(
+      v1AccountBadgeBookmarkResponseBody,
+    ),
+  );
+}
+
+export function v1AccountBadgeBookmarkResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountBadgeBookmarkResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      V1AccountBadgeBookmarkResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountBadgeBookmarkResponseBody' from JSON`,
+  );
+}