@steamsets/client-ts 0.33.6 → 0.33.8

package/src/models/components/v1accountcomparebadgesrequestbody.ts

@@ -0,0 +1,128 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+import {
+  AccountSearch,
+  AccountSearch$Outbound,
+  AccountSearch$outboundSchema,
+} from "./accountsearch.js";
+import { Order, Order$Outbound, Order$outboundSchema } from "./order.js";
+import {
+  RangeFilter,
+  RangeFilter$Outbound,
+  RangeFilter$outboundSchema,
+} from "./rangefilter.js";
+
+export const Filter = {
+  All: "all",
+  Normal: "normal",
+  Foil: "foil",
+} as const;
+export type Filter = ClosedEnum<typeof Filter>;
+
+export const Ignore = {
+  Event: "event",
+  Sale: "sale",
+  Steam: "steam",
+  Infinite: "infinite",
+} as const;
+export type Ignore = ClosedEnum<typeof Ignore>;
+
+export const Match = {
+  Tuple: "tuple",
+  TupleLevel: "tupleLevel",
+  TupleMinLevel: "tupleMinLevel",
+} as const;
+export type Match = ClosedEnum<typeof Match>;
+
+export const Mode = {
+  Missing: "missing",
+  OwnedByAll: "ownedByAll",
+  Unique: "unique",
+} as const;
+export type Mode = ClosedEnum<typeof Mode>;
+
+export type V1AccountCompareBadgesRequestBody = {
+  accounts: Array<AccountSearch> | null;
+  appIds?: Array<number> | null | undefined;
+  appTypes?: Array<string> | null | undefined;
+  excludeAppIds?: Array<number> | null | undefined;
+  filter?: Filter | undefined;
+  ignore?: Array<Ignore> | null | undefined;
+  match?: Match | undefined;
+  /**
+   * Only used when match=tupleMinLevel
+   */
+  minLevel?: number | undefined;
+  mode?: Mode | undefined;
+  order?: Order | undefined;
+  page?: number | undefined;
+  ranges?: Array<RangeFilter> | null | undefined;
+};
+
+/** @internal */
+export const Filter$outboundSchema: z.ZodNativeEnum<typeof Filter> = z
+  .nativeEnum(Filter);
+
+/** @internal */
+export const Ignore$outboundSchema: z.ZodNativeEnum<typeof Ignore> = z
+  .nativeEnum(Ignore);
+
+/** @internal */
+export const Match$outboundSchema: z.ZodNativeEnum<typeof Match> = z.nativeEnum(
+  Match,
+);
+
+/** @internal */
+export const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
+  Mode,
+);
+
+/** @internal */
+export type V1AccountCompareBadgesRequestBody$Outbound = {
+  accounts: Array<AccountSearch$Outbound> | null;
+  appIds?: Array<number> | null | undefined;
+  appTypes?: Array<string> | null | undefined;
+  excludeAppIds?: Array<number> | null | undefined;
+  filter: string;
+  ignore?: Array<string> | null | undefined;
+  match: string;
+  minLevel?: number | undefined;
+  mode: string;
+  order?: Order$Outbound | undefined;
+  page: number;
+  ranges?: Array<RangeFilter$Outbound> | null | undefined;
+};
+
+/** @internal */
+export const V1AccountCompareBadgesRequestBody$outboundSchema: z.ZodType<
+  V1AccountCompareBadgesRequestBody$Outbound,
+  z.ZodTypeDef,
+  V1AccountCompareBadgesRequestBody
+> = z.object({
+  accounts: z.nullable(z.array(AccountSearch$outboundSchema)),
+  appIds: z.nullable(z.array(z.number().int())).optional(),
+  appTypes: z.nullable(z.array(z.string())).optional(),
+  excludeAppIds: z.nullable(z.array(z.number().int())).optional(),
+  filter: Filter$outboundSchema.default("all"),
+  ignore: z.nullable(z.array(Ignore$outboundSchema)).optional(),
+  match: Match$outboundSchema.default("tuple"),
+  minLevel: z.number().int().optional(),
+  mode: Mode$outboundSchema.default("missing"),
+  order: Order$outboundSchema.optional(),
+  page: z.number().int().default(1),
+  ranges: z.nullable(z.array(RangeFilter$outboundSchema)).optional(),
+});
+
+export function v1AccountCompareBadgesRequestBodyToJSON(
+  v1AccountCompareBadgesRequestBody: V1AccountCompareBadgesRequestBody,
+): string {
+  return JSON.stringify(
+    V1AccountCompareBadgesRequestBody$outboundSchema.parse(
+      v1AccountCompareBadgesRequestBody,
+    ),
+  );
+}

package/src/models/components/v1accountcomparebadgesresponsebody.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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";
+import { ComparedTuple, ComparedTuple$inboundSchema } from "./comparedtuple.js";
+import {
+  ResolvedAccount,
+  ResolvedAccount$inboundSchema,
+} from "./resolvedaccount.js";
+
+export type V1AccountCompareBadgesResponseBody = {
+  /**
+   * A URL to the JSON Schema for this object.
+   */
+  dollarSchema?: string | undefined;
+  accounts: Array<ResolvedAccount> | null;
+  /**
+   * The number of pages
+   */
+  pages: number;
+  /**
+   * The total number of hits for all pages
+   */
+  totalHits: number;
+  tuples: Array<ComparedTuple> | null;
+};
+
+/** @internal */
+export const V1AccountCompareBadgesResponseBody$inboundSchema: z.ZodType<
+  V1AccountCompareBadgesResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  $schema: z.string().optional(),
+  accounts: z.nullable(z.array(ResolvedAccount$inboundSchema)),
+  pages: z.number().int(),
+  totalHits: z.number().int(),
+  tuples: z.nullable(z.array(ComparedTuple$inboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    "$schema": "dollarSchema",
+  });
+});
+
+export function v1AccountCompareBadgesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountCompareBadgesResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      V1AccountCompareBadgesResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountCompareBadgesResponseBody' from JSON`,
+  );
+}

package/src/models/components/v1accountlistbadgesrequestbody.ts

@@ -30,18 +30,20 @@ import {
   VanitySearch$outboundSchema,
 } from "./vanitysearch.js";
 
-export const Filter = {
+export const V1AccountListBadgesRequestBodyFilter = {
   Foil: "foil",
   Sale: "sale",
   Event: "event",
 } as const;
-export type Filter = ClosedEnum<typeof Filter>;
+export type V1AccountListBadgesRequestBodyFilter = ClosedEnum<
+  typeof V1AccountListBadgesRequestBodyFilter
+>;
 
 export type V1AccountListBadgesRequestBody = {
   /**
    * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
    */
-  filter?: Array<Filter> | null | undefined;
+  filter?: Array<V1AccountListBadgesRequestBodyFilter> | null | undefined;
   filters?: V1BadgeFilters | undefined;
   id?: IDSearch | undefined;
   order?: V1BadgeOrder | null | undefined;
@@ -55,8 +57,10 @@ export type V1AccountListBadgesRequestBody = {
 };
 
 /** @internal */
-export const Filter$outboundSchema: z.ZodNativeEnum<typeof Filter> = z
-  .nativeEnum(Filter);
+export const V1AccountListBadgesRequestBodyFilter$outboundSchema:
+  z.ZodNativeEnum<typeof V1AccountListBadgesRequestBodyFilter> = z.nativeEnum(
+    V1AccountListBadgesRequestBodyFilter,
+  );
 
 /** @internal */
 export type V1AccountListBadgesRequestBody$Outbound = {
@@ -76,7 +80,9 @@ export const V1AccountListBadgesRequestBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   V1AccountListBadgesRequestBody
 > = z.object({
-  filter: z.nullable(z.array(Filter$outboundSchema)).optional(),
+  filter: z.nullable(
+    z.array(V1AccountListBadgesRequestBodyFilter$outboundSchema),
+  ).optional(),
   filters: V1BadgeFilters$outboundSchema.optional(),
   id: IDSearch$outboundSchema.optional(),
   order: z.nullable(V1BadgeOrder$outboundSchema).optional(),

package/src/models/components/v1apporder.ts

@@ -5,29 +5,31 @@
 import * as z from "zod/v3";
 import { ClosedEnum } from "../../types/enums.js";
 
-export const By = {
+export const V1AppOrderBy = {
   AppId: "appId",
   Playtime: "playtime",
 } as const;
-export type By = ClosedEnum<typeof By>;
+export type V1AppOrderBy = ClosedEnum<typeof V1AppOrderBy>;
 
-export const Direction = {
+export const V1AppOrderDirection = {
   Asc: "asc",
   Desc: "desc",
 } as const;
-export type Direction = ClosedEnum<typeof Direction>;
+export type V1AppOrderDirection = ClosedEnum<typeof V1AppOrderDirection>;
 
 export type V1AppOrder = {
-  by: By;
-  direction?: Direction | undefined;
+  by: V1AppOrderBy;
+  direction?: V1AppOrderDirection | undefined;
 };
 
 /** @internal */
-export const By$outboundSchema: z.ZodNativeEnum<typeof By> = z.nativeEnum(By);
+export const V1AppOrderBy$outboundSchema: z.ZodNativeEnum<typeof V1AppOrderBy> =
+  z.nativeEnum(V1AppOrderBy);
 
 /** @internal */
-export const Direction$outboundSchema: z.ZodNativeEnum<typeof Direction> = z
-  .nativeEnum(Direction);
+export const V1AppOrderDirection$outboundSchema: z.ZodNativeEnum<
+  typeof V1AppOrderDirection
+> = z.nativeEnum(V1AppOrderDirection);
 
 /** @internal */
 export type V1AppOrder$Outbound = {
@@ -41,8 +43,8 @@ export const V1AppOrder$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   V1AppOrder
 > = z.object({
-  by: By$outboundSchema,
-  direction: Direction$outboundSchema.default("desc"),
+  by: V1AppOrderBy$outboundSchema,
+  direction: V1AppOrderDirection$outboundSchema.default("desc"),
 });
 
 export function v1AppOrderToJSON(v1AppOrder: V1AppOrder): string {

package/src/models/operations/comparebadges.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 CompareBadgesResponse = {
+  httpMeta: components.HTTPMetadata;
+  /**
+   * OK
+   */
+  v1AccountCompareBadgesResponseBody?:
+    | components.V1AccountCompareBadgesResponseBody
+    | undefined;
+};
+
+/** @internal */
+export const CompareBadgesResponse$inboundSchema: z.ZodType<
+  CompareBadgesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  V1AccountCompareBadgesResponseBody: components
+    .V1AccountCompareBadgesResponseBody$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "V1AccountCompareBadgesResponseBody": "v1AccountCompareBadgesResponseBody",
+  });
+});
+
+export function compareBadgesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CompareBadgesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CompareBadgesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CompareBadgesResponse' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -65,9 +65,11 @@ export * from "./cmsreorder.js";
 export * from "./cmsupdatedraft.js";
 export * from "./cmsuploadimage.js";
 export * from "./cmsversions.js";
+export * from "./comparebadges.js";
 export * from "./getbucketleaders.js";
 export * from "./getchanges.js";
 export * from "./getviewstats.js";
+export * from "./itemfindowners.js";
 export * from "./leaderboardgetaccountleaderboard.js";
 export * from "./leaderboardgetaccountsmeta.js";
 export * from "./leaderboardgetgroupleaderboard.js";

package/src/models/operations/itemfindowners.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 ItemFindOwnersResponse = {
+  httpMeta: components.HTTPMetadata;
+  /**
+   * OK
+   */
+  findOwnersResponseBody?: components.FindOwnersResponseBody | undefined;
+};
+
+/** @internal */
+export const ItemFindOwnersResponse$inboundSchema: z.ZodType<
+  ItemFindOwnersResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  FindOwnersResponseBody: components.FindOwnersResponseBody$inboundSchema
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "FindOwnersResponseBody": "findOwnersResponseBody",
+  });
+});
+
+export function itemFindOwnersResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ItemFindOwnersResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ItemFindOwnersResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ItemFindOwnersResponse' from JSON`,
+  );
+}

package/src/sdk/account.ts

@@ -7,6 +7,7 @@ import { accountAccountGetBadgeHeatmap } from "../funcs/accountAccountGetBadgeHe
 import { accountAccountGetTrending } from "../funcs/accountAccountGetTrending.js";
 import { accountAccountListOwnedGroups } from "../funcs/accountAccountListOwnedGroups.js";
 import { accountBookmarkBadge } from "../funcs/accountBookmarkBadge.js";
+import { accountCompareBadges } from "../funcs/accountCompareBadges.js";
 import { accountCreateConnection } from "../funcs/accountCreateConnection.js";
 import { accountCreateDeveloperApp } from "../funcs/accountCreateDeveloperApp.js";
 import { accountDeleteConnection } from "../funcs/accountDeleteConnection.js";
@@ -65,6 +66,20 @@ export class Account extends ClientSDK {
     ));
   }
 
+  /**
+   * Compare badge collections between accounts
+   */
+  async compareBadges(
+    request: components.V1AccountCompareBadgesRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.CompareBadgesResponse> {
+    return unwrapAsync(accountCompareBadges(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Create OAuth or domain connection
    */

package/src/sdk/item.ts

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { itemFindOwners } from "../funcs/itemFindOwners.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";
+
+export class Item extends ClientSDK {
+  /**
+   * Find owners of one or more trading cards or booster packs, with friend paths from the requester
+   */
+  async findOwners(
+    request: components.FindOwnersRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.ItemFindOwnersResponse> {
+    return unwrapAsync(itemFindOwners(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -11,6 +11,7 @@ import { Apps } from "./apps.js";
 import { Badge } from "./badge.js";
 import { Badges } from "./badges.js";
 import { Cms } from "./cms.js";
+import { Item } from "./item.js";
 import { Leaderboard } from "./leaderboard.js";
 import { Leaderboards } from "./leaderboards.js";
 import { Location } from "./location.js";
@@ -60,6 +61,11 @@ export class SteamSets extends ClientSDK {
     return (this._cms ??= new Cms(this._options));
   }
 
+  private _item?: Item;
+  get item(): Item {
+    return (this._item ??= new Item(this._options));
+  }
+
   private _leaderboard?: Leaderboard;
   get leaderboard(): Leaderboard {
     return (this._leaderboard ??= new Leaderboard(this._options));