@steamsets/client-ts 0.10.1 → 0.10.3

package/src/lib/sdks.ts

@@ -71,11 +71,11 @@ const isBrowserLike = webWorkerLike
   || (typeof window === "object" && typeof window.document !== "undefined");
 
 export class ClientSDK {
-  private readonly httpClient: HTTPClient;
-  protected readonly baseURL: URL | null;
-  protected readonly hooks$: SDKHooks;
-  protected readonly logger?: Logger | undefined;
-  public readonly options$: SDKOptions & { hooks?: SDKHooks };
+  readonly #httpClient: HTTPClient;
+  readonly #hooks: SDKHooks;
+  readonly #logger?: Logger | undefined;
+  protected readonly _baseURL: URL | null;
+  public readonly _options: SDKOptions & { hooks?: SDKHooks };
 
   constructor(options: SDKOptions = {}) {
     const opt = options as unknown;
@@ -85,33 +85,33 @@ export class ClientSDK {
       && "hooks" in opt
       && opt.hooks instanceof SDKHooks
     ) {
-      this.hooks$ = opt.hooks;
+      this.#hooks = opt.hooks;
     } else {
-      this.hooks$ = new SDKHooks();
+      this.#hooks = new SDKHooks();
     }
-    this.options$ = { ...options, hooks: this.hooks$ };
+    this._options = { ...options, hooks: this.#hooks };
 
     const url = serverURLFromOptions(options);
     if (url) {
       url.pathname = url.pathname.replace(/\/+$/, "") + "/";
     }
-    const { baseURL, client } = this.hooks$.sdkInit({
+    const { baseURL, client } = this.#hooks.sdkInit({
       baseURL: url,
       client: options.httpClient || new HTTPClient(),
     });
-    this.baseURL = baseURL;
-    this.httpClient = client;
-    this.logger = options.debugLogger;
+    this._baseURL = baseURL;
+    this.#httpClient = client;
+    this.#logger = options.debugLogger;
   }
 
-  public createRequest$(
+  public _createRequest(
     context: HookContext,
     conf: RequestConfig,
     options?: RequestOptions,
   ): Result<Request, InvalidRequestError | UnexpectedClientError> {
     const { method, path, query, headers: opHeaders, security } = conf;
 
-    const base = conf.baseURL ?? this.baseURL;
+    const base = conf.baseURL ?? this._baseURL;
     if (!base) {
       return ERR(new InvalidRequestError("No base URL provided for operation"));
     }
@@ -195,7 +195,7 @@ export class ClientSDK {
 
     let input;
     try {
-      input = this.hooks$.beforeCreateRequest(context, {
+      input = this.#hooks.beforeCreateRequest(context, {
         url: reqURL,
         options: {
           ...fetchOptions,
@@ -215,7 +215,7 @@ export class ClientSDK {
     return OK(new Request(input.url, input.options));
   }
 
-  public async do$(
+  public async _do(
     request: Request,
     options: {
       context: HookContext;
@@ -238,25 +238,25 @@ export class ClientSDK {
 
     return retry(
       async () => {
-        const req = await this.hooks$.beforeRequest(context, request.clone());
-        await logRequest(this.logger, req).catch((e) =>
-          this.logger?.log("Failed to log request:", e)
+        const req = await this.#hooks.beforeRequest(context, request.clone());
+        await logRequest(this.#logger, req).catch((e) =>
+          this.#logger?.log("Failed to log request:", e)
         );
 
-        let response = await this.httpClient.request(req);
+        let response = await this.#httpClient.request(req);
 
         if (matchStatusCode(response, errorCodes)) {
-          const result = await this.hooks$.afterError(context, response, null);
+          const result = await this.#hooks.afterError(context, response, null);
           if (result.error) {
             throw result.error;
           }
           response = result.response || response;
         } else {
-          response = await this.hooks$.afterSuccess(context, response);
+          response = await this.#hooks.afterSuccess(context, response);
         }
 
-        await logResponse(this.logger, response, req)
-          .catch(e => this.logger?.log("Failed to log response:", e));
+        await logResponse(this.#logger, response, req)
+          .catch(e => this.#logger?.log("Failed to log response:", e));
 
         return response;
       },

package/src/models/components/index.ts

@@ -35,7 +35,11 @@ export * from "./v1accountbadgecompletion.js";
 export * from "./v1accountdatapointsresponsebody.js";
 export * from "./v1accountfriend.js";
 export * from "./v1accountfriendsresponsebody.js";
+export * from "./v1accountleaderboardaccount.js";
+export * from "./v1accountleaderboardbadgeinfo.js";
 export * from "./v1accountleaderboardhistoryresponsebody.js";
+export * from "./v1accountleaderboardrequestbody.js";
+export * from "./v1accountleaderboardresponsebody.js";
 export * from "./v1accountsappsresponsebody.js";
 export * from "./v1appbadge.js";
 export * from "./v1appdetail.js";
@@ -54,6 +58,7 @@ export * from "./v1deletesessionrequestbody.js";
 export * from "./v1deletesessionresponsebody.js";
 export * from "./v1getsessionbody.js";
 export * from "./v1getsettingsbody.js";
+export * from "./v1leaderboardlocation.js";
 export * from "./v1livenessresponsebody.js";
 export * from "./v1loginresponsebody.js";
 export * from "./v1updateconnectionrequestbody.js";

package/src/models/components/v1accountleaderboardaccount.ts

@@ -0,0 +1,310 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import {
+  LeaderboardBadgeInfo,
+  LeaderboardBadgeInfo$inboundSchema,
+  LeaderboardBadgeInfo$Outbound,
+  LeaderboardBadgeInfo$outboundSchema,
+} from "./leaderboardbadgeinfo.js";
+import {
+  Location,
+  Location$inboundSchema,
+  Location$Outbound,
+  Location$outboundSchema,
+} from "./location.js";
+import {
+  Role,
+  Role$inboundSchema,
+  Role$Outbound,
+  Role$outboundSchema,
+} from "./role.js";
+
+export type V1AccountLeaderboardAccount = {
+  /**
+   * The cost of an app
+   */
+  appCost: number;
+  /**
+   * The playtime of the account, incase of an app leaderboard
+   */
+  appPlaytime?: number | null | undefined;
+  /**
+   * The number of apps the account has
+   */
+  apps: number;
+  /**
+   * The avatar hash of the account
+   */
+  avatar: string;
+  /**
+   * The average playtime of the account
+   */
+  averagePlaytime: number;
+  /**
+   * The number of awards the account has
+   */
+  awardsGiven: number;
+  /**
+   * The number of awards the account has
+   */
+  awardsReceived: number;
+  badgeInfo?: LeaderboardBadgeInfo | undefined;
+  /**
+   * The number of badges the account has
+   */
+  badges: number;
+  /**
+   * The number of bans
+   */
+  bans: number;
+  city?: Location | undefined;
+  country?: Location | undefined;
+  /**
+   * The time the account was created
+   */
+  createdAt: Date;
+  /**
+   * The economy ban of the account
+   */
+  economyBan: string;
+  /**
+   * The cost of a foil badge
+   */
+  foilBadgeCost: number;
+  /**
+   * The number of foil badges the account has
+   */
+  foilBadges: number;
+  /**
+   * The number of friends the account has
+   */
+  friends: number;
+  /**
+   * The number of game bans
+   */
+  gameBans: number;
+  /**
+   * Whether the account is hidden in the leaderboards
+   */
+  hidden: boolean;
+  /**
+   * The level of the account
+   */
+  level: number;
+  /**
+   * The number of limited apps the account has
+   */
+  limitedApps: number;
+  /**
+   * The name of the account
+   */
+  name: string;
+  /**
+   * The cost of a normal badge
+   */
+  normalBadgeCost: number;
+  /**
+   * The number of normal badges the account has
+   */
+  normalBadges: number;
+  /**
+   * The playtime of the account
+   */
+  playtime: number;
+  /**
+   * The number of points the account has
+   */
+  pointsGiven: number;
+  /**
+   * The number of points the account has
+   */
+  pointsReceived: number;
+  /**
+   * The privacy of the account
+   */
+  privacy: string;
+  /**
+   * The rank of the account
+   */
+  rank: number;
+  region?: Location | undefined;
+  /**
+   * The roles of the account
+   */
+  roles: Array<Role> | null;
+  state?: Location | undefined;
+  /**
+   * The steam id
+   */
+  steamId: string;
+  /**
+   * The steam sets score
+   */
+  steamSetsScore: number;
+  /**
+   * The vanity of the account
+   */
+  steamSetsVanity: string;
+  /**
+   * The vanity of the account
+   */
+  steamVanity: string;
+  /**
+   * The number of vac bans
+   */
+  vacBans: number;
+  /**
+   * The number of xp the account has
+   */
+  xp: number;
+};
+
+/** @internal */
+export const V1AccountLeaderboardAccount$inboundSchema: z.ZodType<
+  V1AccountLeaderboardAccount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  appCost: z.number().int(),
+  appPlaytime: z.nullable(z.number().int()).optional(),
+  apps: z.number().int(),
+  avatar: z.string(),
+  averagePlaytime: z.number().int(),
+  awardsGiven: z.number().int(),
+  awardsReceived: z.number().int(),
+  badgeInfo: LeaderboardBadgeInfo$inboundSchema.optional(),
+  badges: z.number().int(),
+  bans: z.number().int(),
+  city: Location$inboundSchema.optional(),
+  country: Location$inboundSchema.optional(),
+  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  economyBan: z.string(),
+  foilBadgeCost: z.number().int(),
+  foilBadges: z.number().int(),
+  friends: z.number().int(),
+  gameBans: z.number().int(),
+  hidden: z.boolean(),
+  level: z.number().int(),
+  limitedApps: z.number().int(),
+  name: z.string(),
+  normalBadgeCost: z.number().int(),
+  normalBadges: z.number().int(),
+  playtime: z.number().int(),
+  pointsGiven: z.number().int(),
+  pointsReceived: z.number().int(),
+  privacy: z.string(),
+  rank: z.number().int(),
+  region: Location$inboundSchema.optional(),
+  roles: z.nullable(z.array(Role$inboundSchema)),
+  state: Location$inboundSchema.optional(),
+  steamId: z.string(),
+  steamSetsScore: z.number().int(),
+  steamSetsVanity: z.string(),
+  steamVanity: z.string(),
+  vacBans: z.number().int(),
+  xp: z.number().int(),
+});
+
+/** @internal */
+export type V1AccountLeaderboardAccount$Outbound = {
+  appCost: number;
+  appPlaytime?: number | null | undefined;
+  apps: number;
+  avatar: string;
+  averagePlaytime: number;
+  awardsGiven: number;
+  awardsReceived: number;
+  badgeInfo?: LeaderboardBadgeInfo$Outbound | undefined;
+  badges: number;
+  bans: number;
+  city?: Location$Outbound | undefined;
+  country?: Location$Outbound | undefined;
+  createdAt: string;
+  economyBan: string;
+  foilBadgeCost: number;
+  foilBadges: number;
+  friends: number;
+  gameBans: number;
+  hidden: boolean;
+  level: number;
+  limitedApps: number;
+  name: string;
+  normalBadgeCost: number;
+  normalBadges: number;
+  playtime: number;
+  pointsGiven: number;
+  pointsReceived: number;
+  privacy: string;
+  rank: number;
+  region?: Location$Outbound | undefined;
+  roles: Array<Role$Outbound> | null;
+  state?: Location$Outbound | undefined;
+  steamId: string;
+  steamSetsScore: number;
+  steamSetsVanity: string;
+  steamVanity: string;
+  vacBans: number;
+  xp: number;
+};
+
+/** @internal */
+export const V1AccountLeaderboardAccount$outboundSchema: z.ZodType<
+  V1AccountLeaderboardAccount$Outbound,
+  z.ZodTypeDef,
+  V1AccountLeaderboardAccount
+> = z.object({
+  appCost: z.number().int(),
+  appPlaytime: z.nullable(z.number().int()).optional(),
+  apps: z.number().int(),
+  avatar: z.string(),
+  averagePlaytime: z.number().int(),
+  awardsGiven: z.number().int(),
+  awardsReceived: z.number().int(),
+  badgeInfo: LeaderboardBadgeInfo$outboundSchema.optional(),
+  badges: z.number().int(),
+  bans: z.number().int(),
+  city: Location$outboundSchema.optional(),
+  country: Location$outboundSchema.optional(),
+  createdAt: z.date().transform(v => v.toISOString()),
+  economyBan: z.string(),
+  foilBadgeCost: z.number().int(),
+  foilBadges: z.number().int(),
+  friends: z.number().int(),
+  gameBans: z.number().int(),
+  hidden: z.boolean(),
+  level: z.number().int(),
+  limitedApps: z.number().int(),
+  name: z.string(),
+  normalBadgeCost: z.number().int(),
+  normalBadges: z.number().int(),
+  playtime: z.number().int(),
+  pointsGiven: z.number().int(),
+  pointsReceived: z.number().int(),
+  privacy: z.string(),
+  rank: z.number().int(),
+  region: Location$outboundSchema.optional(),
+  roles: z.nullable(z.array(Role$outboundSchema)),
+  state: Location$outboundSchema.optional(),
+  steamId: z.string(),
+  steamSetsScore: z.number().int(),
+  steamSetsVanity: z.string(),
+  steamVanity: z.string(),
+  vacBans: z.number().int(),
+  xp: z.number().int(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountLeaderboardAccount$ {
+  /** @deprecated use `V1AccountLeaderboardAccount$inboundSchema` instead. */
+  export const inboundSchema = V1AccountLeaderboardAccount$inboundSchema;
+  /** @deprecated use `V1AccountLeaderboardAccount$outboundSchema` instead. */
+  export const outboundSchema = V1AccountLeaderboardAccount$outboundSchema;
+  /** @deprecated use `V1AccountLeaderboardAccount$Outbound` instead. */
+  export type Outbound = V1AccountLeaderboardAccount$Outbound;
+}

package/src/models/components/v1accountleaderboardbadgeinfo.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export type V1AccountLeaderboardBadgeInfo = {};
+
+/** @internal */
+export const V1AccountLeaderboardBadgeInfo$inboundSchema: z.ZodType<
+  V1AccountLeaderboardBadgeInfo,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type V1AccountLeaderboardBadgeInfo$Outbound = {};
+
+/** @internal */
+export const V1AccountLeaderboardBadgeInfo$outboundSchema: z.ZodType<
+  V1AccountLeaderboardBadgeInfo$Outbound,
+  z.ZodTypeDef,
+  V1AccountLeaderboardBadgeInfo
+> = z.object({});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountLeaderboardBadgeInfo$ {
+  /** @deprecated use `V1AccountLeaderboardBadgeInfo$inboundSchema` instead. */
+  export const inboundSchema = V1AccountLeaderboardBadgeInfo$inboundSchema;
+  /** @deprecated use `V1AccountLeaderboardBadgeInfo$outboundSchema` instead. */
+  export const outboundSchema = V1AccountLeaderboardBadgeInfo$outboundSchema;
+  /** @deprecated use `V1AccountLeaderboardBadgeInfo$Outbound` instead. */
+  export type Outbound = V1AccountLeaderboardBadgeInfo$Outbound;
+}

package/src/models/components/v1accountleaderboardrequestbody.ts

@@ -0,0 +1,148 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+import {
+  V1LeaderboardLocation,
+  V1LeaderboardLocation$inboundSchema,
+  V1LeaderboardLocation$Outbound,
+  V1LeaderboardLocation$outboundSchema,
+} from "./v1leaderboardlocation.js";
+
+/**
+ * The leaderboard to get
+ */
+export const V1AccountLeaderboardRequestBodyLeaderboard = {
+  Apps: "apps",
+  LimitedApps: "limited_apps",
+  AppPlaytime: "app_playtime",
+  AwardsGiven: "awards_given",
+  AwardsReceived: "awards_received",
+  Bans: "bans",
+  GameBans: "game_bans",
+  VacBans: "vac_bans",
+  Donations: "donations",
+  FoilBadges: "foil_badges",
+  NormalBadges: "normal_badges",
+  Badges: "badges",
+  Playtime: "playtime",
+  PointsGiven: "points_given",
+  PointsReceived: "points_received",
+  SteamSets: "steam_sets",
+  Xp: "xp",
+  BadgeCompletionTime: "badge_completion_time",
+  BadgeHighestLevel: "badge_highest_level",
+} as const;
+/**
+ * The leaderboard to get
+ */
+export type V1AccountLeaderboardRequestBodyLeaderboard = ClosedEnum<
+  typeof V1AccountLeaderboardRequestBodyLeaderboard
+>;
+
+export type V1AccountLeaderboardRequestBody = {
+  /**
+   * For a given app leaderboard, the app id
+   */
+  appId?: number | null | undefined;
+  /**
+   * For a given badge leaderboard, the steam badge id
+   */
+  badgeId?: string | null | undefined;
+  /**
+   * For a given badge leaderboard, whether the badge is foil or not
+   */
+  badgeIsFoil?: boolean | null | undefined;
+  /**
+   * The end index
+   */
+  end?: number | null | undefined;
+  /**
+   * The leaderboard to get
+   */
+  leaderboard: V1AccountLeaderboardRequestBodyLeaderboard;
+  location?: V1LeaderboardLocation | undefined;
+  /**
+   * The start index
+   */
+  start?: number | null | undefined;
+};
+
+/** @internal */
+export const V1AccountLeaderboardRequestBodyLeaderboard$inboundSchema:
+  z.ZodNativeEnum<typeof V1AccountLeaderboardRequestBodyLeaderboard> = z
+    .nativeEnum(V1AccountLeaderboardRequestBodyLeaderboard);
+
+/** @internal */
+export const V1AccountLeaderboardRequestBodyLeaderboard$outboundSchema:
+  z.ZodNativeEnum<typeof V1AccountLeaderboardRequestBodyLeaderboard> =
+    V1AccountLeaderboardRequestBodyLeaderboard$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountLeaderboardRequestBodyLeaderboard$ {
+  /** @deprecated use `V1AccountLeaderboardRequestBodyLeaderboard$inboundSchema` instead. */
+  export const inboundSchema =
+    V1AccountLeaderboardRequestBodyLeaderboard$inboundSchema;
+  /** @deprecated use `V1AccountLeaderboardRequestBodyLeaderboard$outboundSchema` instead. */
+  export const outboundSchema =
+    V1AccountLeaderboardRequestBodyLeaderboard$outboundSchema;
+}
+
+/** @internal */
+export const V1AccountLeaderboardRequestBody$inboundSchema: z.ZodType<
+  V1AccountLeaderboardRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  appId: z.nullable(z.number().int()).optional(),
+  badgeId: z.nullable(z.string()).optional(),
+  badgeIsFoil: z.nullable(z.boolean()).optional(),
+  end: z.nullable(z.number().int()).optional(),
+  leaderboard: V1AccountLeaderboardRequestBodyLeaderboard$inboundSchema,
+  location: V1LeaderboardLocation$inboundSchema.optional(),
+  start: z.nullable(z.number().int()).optional(),
+});
+
+/** @internal */
+export type V1AccountLeaderboardRequestBody$Outbound = {
+  appId?: number | null | undefined;
+  badgeId?: string | null | undefined;
+  badgeIsFoil?: boolean | null | undefined;
+  end?: number | null | undefined;
+  leaderboard: string;
+  location?: V1LeaderboardLocation$Outbound | undefined;
+  start?: number | null | undefined;
+};
+
+/** @internal */
+export const V1AccountLeaderboardRequestBody$outboundSchema: z.ZodType<
+  V1AccountLeaderboardRequestBody$Outbound,
+  z.ZodTypeDef,
+  V1AccountLeaderboardRequestBody
+> = z.object({
+  appId: z.nullable(z.number().int()).optional(),
+  badgeId: z.nullable(z.string()).optional(),
+  badgeIsFoil: z.nullable(z.boolean()).optional(),
+  end: z.nullable(z.number().int()).optional(),
+  leaderboard: V1AccountLeaderboardRequestBodyLeaderboard$outboundSchema,
+  location: V1LeaderboardLocation$outboundSchema.optional(),
+  start: z.nullable(z.number().int()).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1AccountLeaderboardRequestBody$ {
+  /** @deprecated use `V1AccountLeaderboardRequestBody$inboundSchema` instead. */
+  export const inboundSchema = V1AccountLeaderboardRequestBody$inboundSchema;
+  /** @deprecated use `V1AccountLeaderboardRequestBody$outboundSchema` instead. */
+  export const outboundSchema = V1AccountLeaderboardRequestBody$outboundSchema;
+  /** @deprecated use `V1AccountLeaderboardRequestBody$Outbound` instead. */
+  export type Outbound = V1AccountLeaderboardRequestBody$Outbound;
+}