@steamsets/client-ts 0.26.8 → 0.27.0

package/src/funcs/badgesListPrices.ts

@@ -3,10 +3,8 @@
  */
 
 import { SteamSetsCore } from "../core.js";
-import { encodeJSON } from "../lib/encodings.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
-import { safeParse } from "../lib/schemas.js";
 import { RequestOptions } from "../lib/sdks.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
@@ -18,7 +16,6 @@ import {
   RequestTimeoutError,
   UnexpectedClientError,
 } from "../models/errors/httpclienterrors.js";
-import * as errors from "../models/errors/index.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import { SteamSetsError } from "../models/errors/steamsetserror.js";
@@ -26,14 +23,24 @@ import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
+export enum ListPricesAcceptEnum {
+  applicationJson = "application/json",
+  applicationProblemPlusJson = "application/problem+json",
+}
+
+/**
+ * List badge prices
+ *
+ * @remarks
+ * Get a list of all badge pricing information
+ */
 export function badgesListPrices(
   client: SteamSetsCore,
-  request: components.V1BadgeListBadgePricesRequestBody,
-  options?: RequestOptions,
+  _request: components.V1BadgeListBadgePricesRequestBody,
+  options?: RequestOptions & { acceptHeaderOverride?: ListPricesAcceptEnum },
 ): APIPromise<
   Result<
     operations.BadgeListBadgePricesResponse,
-    | errors.ErrorModel
     | SteamSetsError
     | ResponseValidationError
     | ConnectionError
@@ -46,20 +53,19 @@ export function badgesListPrices(
 > {
   return new APIPromise($do(
     client,
-    request,
+    _request,
     options,
   ));
 }
 
 async function $do(
   client: SteamSetsCore,
-  request: components.V1BadgeListBadgePricesRequestBody,
-  options?: RequestOptions,
+  _request: components.V1BadgeListBadgePricesRequestBody,
+  options?: RequestOptions & { acceptHeaderOverride?: ListPricesAcceptEnum },
 ): Promise<
   [
     Result<
       operations.BadgeListBadgePricesResponse,
-      | errors.ErrorModel
       | SteamSetsError
       | ResponseValidationError
       | ConnectionError
@@ -72,23 +78,12 @@ async function $do(
     APICall,
   ]
 > {
-  const parsed = safeParse(
-    request,
-    (value) =>
-      components.V1BadgeListBadgePricesRequestBody$outboundSchema.parse(value),
-    "Input validation failed",
-  );
-  if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
-  }
-  const payload = parsed.value;
-  const body = encodeJSON("body", payload, { explode: true });
-
   const path = pathToFunc("/v1/badge.listBadgePrices")();
 
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
-    Accept: "application/json",
+    Accept: options?.acceptHeaderOverride
+      || "application/json;q=1, application/problem+json;q=0",
   }));
 
   const secConfig = await extractSecurity(client._options.token);
@@ -126,7 +121,6 @@ async function $do(
     baseURL: options?.serverURL,
     path: path,
     headers: headers,
-    body: body,
     uaHeader: "x-speakeasy-user-agent",
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
@@ -138,7 +132,7 @@ async function $do(
 
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["403", "404", "422", "4XX", "500", "5XX"],
+    errorCodes: ["4XX", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes,
   });
@@ -153,7 +147,6 @@ async function $do(
 
   const [result] = await M.match<
     operations.BadgeListBadgePricesResponse,
-    | errors.ErrorModel
     | SteamSetsError
     | ResponseValidationError
     | ConnectionError
@@ -166,14 +159,12 @@ async function $do(
     M.json(200, operations.BadgeListBadgePricesResponse$inboundSchema, {
       key: "V1BadgeListBadgePricesResponseBody",
     }),
-    M.jsonErr([403, 404, 422], errors.ErrorModel$inboundSchema, {
-      ctype: "application/problem+json",
-    }),
-    M.jsonErr(500, errors.ErrorModel$inboundSchema, {
-      ctype: "application/problem+json",
-    }),
     M.fail("4XX"),
     M.fail("5XX"),
+    M.json("default", operations.BadgeListBadgePricesResponse$inboundSchema, {
+      ctype: "application/problem+json",
+      key: "ErrorModel",
+    }),
   )(response, req, { extraFields: responseFields });
   if (!result.ok) {
     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.26.8",
-  genVersion: "2.629.1",
+  sdkVersion: "0.27.0",
+  genVersion: "2.632.2",
   userAgent:
-    "speakeasy-sdk/typescript 0.26.8 2.629.1 1.0.0 @steamsets/client-ts",
+    "speakeasy-sdk/typescript 0.27.0 2.632.2 1.0.0 @steamsets/client-ts",
 } as const;

package/src/models/components/badge.ts

@@ -20,10 +20,12 @@ export type Badge = {
   appImage: string;
   appName: string;
   bookmarks: number;
+  cardCount: number;
   colors: Array<string> | null;
   designs: Array<string> | null;
   firstCompletion: number;
   highestLevel: number;
+  highestPrice: number;
   id: string;
   image: string;
   isEvent: boolean;
@@ -31,7 +33,9 @@ export type Badge = {
   isSale: boolean;
   lastCompletion: number;
   level: number;
+  lowestPrice: number;
   name: string;
+  price: number;
   scarcity: number;
   steamId: number;
   xp: number;
@@ -45,10 +49,12 @@ export const Badge$inboundSchema: z.ZodType<Badge, z.ZodTypeDef, unknown> = z
     appImage: z.string(),
     appName: z.string(),
     bookmarks: z.number().int(),
+    cardCount: z.number().int(),
     colors: z.nullable(z.array(z.string())),
     designs: z.nullable(z.array(z.string())),
     firstCompletion: z.number().int(),
     highestLevel: z.number().int(),
+    highestPrice: z.number(),
     id: z.string(),
     image: z.string(),
     isEvent: z.boolean(),
@@ -56,7 +62,9 @@ export const Badge$inboundSchema: z.ZodType<Badge, z.ZodTypeDef, unknown> = z
     isSale: z.boolean(),
     lastCompletion: z.number().int(),
     level: z.number().int(),
+    lowestPrice: z.number(),
     name: z.string(),
+    price: z.number(),
     scarcity: z.number().int(),
     steamId: z.number().int(),
     xp: z.number(),
@@ -73,10 +81,12 @@ export type Badge$Outbound = {
   appImage: string;
   appName: string;
   bookmarks: number;
+  cardCount: number;
   colors: Array<string> | null;
   designs: Array<string> | null;
   firstCompletion: number;
   highestLevel: number;
+  highestPrice: number;
   id: string;
   image: string;
   isEvent: boolean;
@@ -84,7 +94,9 @@ export type Badge$Outbound = {
   isSale: boolean;
   lastCompletion: number;
   level: number;
+  lowestPrice: number;
   name: string;
+  price: number;
   scarcity: number;
   steamId: number;
   xp: number;
@@ -101,10 +113,12 @@ export const Badge$outboundSchema: z.ZodType<
   appImage: z.string(),
   appName: z.string(),
   bookmarks: z.number().int(),
+  cardCount: z.number().int(),
   colors: z.nullable(z.array(z.string())),
   designs: z.nullable(z.array(z.string())),
   firstCompletion: z.number().int(),
   highestLevel: z.number().int(),
+  highestPrice: z.number(),
   id: z.string(),
   image: z.string(),
   isEvent: z.boolean(),
@@ -112,7 +126,9 @@ export const Badge$outboundSchema: z.ZodType<
   isSale: z.boolean(),
   lastCompletion: z.number().int(),
   level: z.number().int(),
+  lowestPrice: z.number(),
   name: z.string(),
+  price: z.number(),
   scarcity: z.number().int(),
   steamId: z.number().int(),
   xp: z.number(),

package/src/models/components/errormodel.ts

@@ -0,0 +1,122 @@
+/*
+ * 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";
+import {
+  ErrorDetail,
+  ErrorDetail$inboundSchema,
+  ErrorDetail$Outbound,
+  ErrorDetail$outboundSchema,
+} from "./errordetail.js";
+
+export type ErrorModel = {
+  /**
+   * A URL to the JSON Schema for this object.
+   */
+  dollarSchema?: string | undefined;
+  /**
+   * A human-readable explanation specific to this occurrence of the problem.
+   */
+  detail?: string | undefined;
+  /**
+   * Optional list of individual error details
+   */
+  errors?: Array<ErrorDetail> | null | undefined;
+  /**
+   * A URI reference that identifies the specific occurrence of the problem.
+   */
+  instance?: string | undefined;
+  /**
+   * HTTP status code
+   */
+  status?: number | undefined;
+  /**
+   * A short, human-readable summary of the problem type. This value should not change between occurrences of the error.
+   */
+  title?: string | undefined;
+  /**
+   * A URI reference to human-readable documentation for the error.
+   */
+  type?: string | undefined;
+};
+
+/** @internal */
+export const ErrorModel$inboundSchema: z.ZodType<
+  ErrorModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  $schema: z.string().optional(),
+  detail: z.string().optional(),
+  errors: z.nullable(z.array(ErrorDetail$inboundSchema)).optional(),
+  instance: z.string().optional(),
+  status: z.number().int().optional(),
+  title: z.string().optional(),
+  type: z.string().default("about:blank"),
+}).transform((v) => {
+  return remap$(v, {
+    "$schema": "dollarSchema",
+  });
+});
+
+/** @internal */
+export type ErrorModel$Outbound = {
+  $schema?: string | undefined;
+  detail?: string | undefined;
+  errors?: Array<ErrorDetail$Outbound> | null | undefined;
+  instance?: string | undefined;
+  status?: number | undefined;
+  title?: string | undefined;
+  type: string;
+};
+
+/** @internal */
+export const ErrorModel$outboundSchema: z.ZodType<
+  ErrorModel$Outbound,
+  z.ZodTypeDef,
+  ErrorModel
+> = z.object({
+  dollarSchema: z.string().optional(),
+  detail: z.string().optional(),
+  errors: z.nullable(z.array(ErrorDetail$outboundSchema)).optional(),
+  instance: z.string().optional(),
+  status: z.number().int().optional(),
+  title: z.string().optional(),
+  type: z.string().default("about:blank"),
+}).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 ErrorModel$ {
+  /** @deprecated use `ErrorModel$inboundSchema` instead. */
+  export const inboundSchema = ErrorModel$inboundSchema;
+  /** @deprecated use `ErrorModel$outboundSchema` instead. */
+  export const outboundSchema = ErrorModel$outboundSchema;
+  /** @deprecated use `ErrorModel$Outbound` instead. */
+  export type Outbound = ErrorModel$Outbound;
+}
+
+export function errorModelToJSON(errorModel: ErrorModel): string {
+  return JSON.stringify(ErrorModel$outboundSchema.parse(errorModel));
+}
+
+export function errorModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ErrorModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ErrorModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ErrorModel' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -19,6 +19,7 @@ export * from "./currentcolortag.js";
 export * from "./designtag.js";
 export * from "./developerapp.js";
 export * from "./errordetail.js";
+export * from "./errormodel.js";
 export * from "./historyvalue.js";
 export * from "./httpmetadata.js";
 export * from "./idstruct.js";
@@ -117,21 +118,25 @@ export * from "./v1applistbadgesrequestbody.js";
 export * from "./v1applistbadgesresponsebody.js";
 export * from "./v1apporder.js";
 export * from "./v1badgeaccount.js";
+export * from "./v1badgeapp.js";
+export * from "./v1badgelevel.js";
 export * from "./v1badgelistaccountsrequestbody.js";
 export * from "./v1badgelistaccountsresponsebody.js";
-export * from "./v1badgelistbadgepricefilters.js";
-export * from "./v1badgelistbadgepriceorder.js";
 export * from "./v1badgelistbadgepricesrequestbody.js";
 export * from "./v1badgelistbadgepricesresponsebody.js";
 export * from "./v1badgelisttagsresponsebody.js";
 export * from "./v1badgelookup.js";
 export * from "./v1badgeorder.js";
 export * from "./v1badgesearchbadgesresponsebody.js";
+export * from "./v1badgeset.js";
+export * from "./v1badgesetcount.js";
+export * from "./v1badgesetcounts.js";
 export * from "./v1badgesuggestsearchbody.js";
 export * from "./v1badgesuggestsearchrequestbody.js";
 export * from "./v1badgesuggesttagsrequestbody.js";
 export * from "./v1badgetagbadgerequestbody.js";
 export * from "./v1badgetagbadgeresponsebody.js";
+export * from "./v1badgetypecount.js";
 export * from "./v1groupleaderboardgroup.js";
 export * from "./v1leaderboardappinfo.js";
 export * from "./v1leaderboardbadge.js";

package/src/models/components/v1accountgetinforesponsebody.ts

@@ -87,10 +87,7 @@ export const LastQueueStatus = {
   Undefined: "undefined",
   Pending: "pending",
   InProgress: "in_progress",
-  Retrying: "retrying",
-  Failed: "failed",
   Completed: "completed",
-  Cooldown: "cooldown",
 } as const;
 export type LastQueueStatus = ClosedEnum<typeof LastQueueStatus>;
 

package/src/models/components/v1badgeapp.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 V1BadgeApp = {
+  bgAvg: number;
+  boosterPrice: number | null;
+  emoteAvg: number;
+  image: string;
+  name: string;
+};
+
+/** @internal */
+export const V1BadgeApp$inboundSchema: z.ZodType<
+  V1BadgeApp,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bgAvg: z.number().int(),
+  boosterPrice: z.nullable(z.number().int()),
+  emoteAvg: z.number().int(),
+  image: z.string(),
+  name: z.string(),
+});
+
+/** @internal */
+export type V1BadgeApp$Outbound = {
+  bgAvg: number;
+  boosterPrice: number | null;
+  emoteAvg: number;
+  image: string;
+  name: string;
+};
+
+/** @internal */
+export const V1BadgeApp$outboundSchema: z.ZodType<
+  V1BadgeApp$Outbound,
+  z.ZodTypeDef,
+  V1BadgeApp
+> = z.object({
+  bgAvg: z.number().int(),
+  boosterPrice: z.nullable(z.number().int()),
+  emoteAvg: z.number().int(),
+  image: z.string(),
+  name: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1BadgeApp$ {
+  /** @deprecated use `V1BadgeApp$inboundSchema` instead. */
+  export const inboundSchema = V1BadgeApp$inboundSchema;
+  /** @deprecated use `V1BadgeApp$outboundSchema` instead. */
+  export const outboundSchema = V1BadgeApp$outboundSchema;
+  /** @deprecated use `V1BadgeApp$Outbound` instead. */
+  export type Outbound = V1BadgeApp$Outbound;
+}
+
+export function v1BadgeAppToJSON(v1BadgeApp: V1BadgeApp): string {
+  return JSON.stringify(V1BadgeApp$outboundSchema.parse(v1BadgeApp));
+}
+
+export function v1BadgeAppFromJSON(
+  jsonString: string,
+): SafeParseResult<V1BadgeApp, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1BadgeApp$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1BadgeApp' from JSON`,
+  );
+}

package/src/models/components/v1badgelevel.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 V1BadgeLevel = {
+  image: string;
+  name: string;
+  scarcity: number;
+};
+
+/** @internal */
+export const V1BadgeLevel$inboundSchema: z.ZodType<
+  V1BadgeLevel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  image: z.string(),
+  name: z.string(),
+  scarcity: z.number().int(),
+});
+
+/** @internal */
+export type V1BadgeLevel$Outbound = {
+  image: string;
+  name: string;
+  scarcity: number;
+};
+
+/** @internal */
+export const V1BadgeLevel$outboundSchema: z.ZodType<
+  V1BadgeLevel$Outbound,
+  z.ZodTypeDef,
+  V1BadgeLevel
+> = z.object({
+  image: z.string(),
+  name: z.string(),
+  scarcity: 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 V1BadgeLevel$ {
+  /** @deprecated use `V1BadgeLevel$inboundSchema` instead. */
+  export const inboundSchema = V1BadgeLevel$inboundSchema;
+  /** @deprecated use `V1BadgeLevel$outboundSchema` instead. */
+  export const outboundSchema = V1BadgeLevel$outboundSchema;
+  /** @deprecated use `V1BadgeLevel$Outbound` instead. */
+  export type Outbound = V1BadgeLevel$Outbound;
+}
+
+export function v1BadgeLevelToJSON(v1BadgeLevel: V1BadgeLevel): string {
+  return JSON.stringify(V1BadgeLevel$outboundSchema.parse(v1BadgeLevel));
+}
+
+export function v1BadgeLevelFromJSON(
+  jsonString: string,
+): SafeParseResult<V1BadgeLevel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1BadgeLevel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1BadgeLevel' from JSON`,
+  );
+}

package/src/models/components/v1badgelistbadgepricesrequestbody.ts

@@ -6,49 +6,25 @@ 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 {
-  V1BadgeListBadgePriceFilters,
-  V1BadgeListBadgePriceFilters$inboundSchema,
-  V1BadgeListBadgePriceFilters$Outbound,
-  V1BadgeListBadgePriceFilters$outboundSchema,
-} from "./v1badgelistbadgepricefilters.js";
-import {
-  V1BadgeListBadgePriceOrder,
-  V1BadgeListBadgePriceOrder$inboundSchema,
-  V1BadgeListBadgePriceOrder$Outbound,
-  V1BadgeListBadgePriceOrder$outboundSchema,
-} from "./v1badgelistbadgepriceorder.js";
 
-export type V1BadgeListBadgePricesRequestBody = {
-  filters?: V1BadgeListBadgePriceFilters | null | undefined;
-  order?: V1BadgeListBadgePriceOrder | null | undefined;
-};
+export type V1BadgeListBadgePricesRequestBody = {};
 
 /** @internal */
 export const V1BadgeListBadgePricesRequestBody$inboundSchema: z.ZodType<
   V1BadgeListBadgePricesRequestBody,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  filters: z.nullable(V1BadgeListBadgePriceFilters$inboundSchema).optional(),
-  order: z.nullable(V1BadgeListBadgePriceOrder$inboundSchema).optional(),
-});
+> = z.object({});
 
 /** @internal */
-export type V1BadgeListBadgePricesRequestBody$Outbound = {
-  filters?: V1BadgeListBadgePriceFilters$Outbound | null | undefined;
-  order?: V1BadgeListBadgePriceOrder$Outbound | null | undefined;
-};
+export type V1BadgeListBadgePricesRequestBody$Outbound = {};
 
 /** @internal */
 export const V1BadgeListBadgePricesRequestBody$outboundSchema: z.ZodType<
   V1BadgeListBadgePricesRequestBody$Outbound,
   z.ZodTypeDef,
   V1BadgeListBadgePricesRequestBody
-> = z.object({
-  filters: z.nullable(V1BadgeListBadgePriceFilters$outboundSchema).optional(),
-  order: z.nullable(V1BadgeListBadgePriceOrder$outboundSchema).optional(),
-});
+> = z.object({});
 
 /**
  * @internal

package/src/models/components/v1badgelistbadgepricesresponsebody.ts

@@ -7,12 +7,43 @@ 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 {
+  V1BadgeApp,
+  V1BadgeApp$inboundSchema,
+  V1BadgeApp$Outbound,
+  V1BadgeApp$outboundSchema,
+} from "./v1badgeapp.js";
+import {
+  V1BadgeSet,
+  V1BadgeSet$inboundSchema,
+  V1BadgeSet$Outbound,
+  V1BadgeSet$outboundSchema,
+} from "./v1badgeset.js";
+import {
+  V1BadgeSetCounts,
+  V1BadgeSetCounts$inboundSchema,
+  V1BadgeSetCounts$Outbound,
+  V1BadgeSetCounts$outboundSchema,
+} from "./v1badgesetcounts.js";
 
 export type V1BadgeListBadgePricesResponseBody = {
   /**
    * A URL to the JSON Schema for this object.
    */
   dollarSchema?: string | undefined;
+  /**
+   * App information indexed by app ID
+   */
+  apps: { [k: string]: V1BadgeApp };
+  setCounts: V1BadgeSetCounts;
+  /**
+   * Badge sets with pricing information
+   */
+  sets: Array<V1BadgeSet> | null;
+  /**
+   * Total number of badge sets
+   */
+  total: number;
 };
 
 /** @internal */
@@ -22,6 +53,10 @@ export const V1BadgeListBadgePricesResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   $schema: z.string().optional(),
+  apps: z.record(V1BadgeApp$inboundSchema),
+  setCounts: V1BadgeSetCounts$inboundSchema,
+  sets: z.nullable(z.array(V1BadgeSet$inboundSchema)),
+  total: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
     "$schema": "dollarSchema",
@@ -31,6 +66,10 @@ export const V1BadgeListBadgePricesResponseBody$inboundSchema: z.ZodType<
 /** @internal */
 export type V1BadgeListBadgePricesResponseBody$Outbound = {
   $schema?: string | undefined;
+  apps: { [k: string]: V1BadgeApp$Outbound };
+  setCounts: V1BadgeSetCounts$Outbound;
+  sets: Array<V1BadgeSet$Outbound> | null;
+  total: number;
 };
 
 /** @internal */
@@ -40,6 +79,10 @@ export const V1BadgeListBadgePricesResponseBody$outboundSchema: z.ZodType<
   V1BadgeListBadgePricesResponseBody
 > = z.object({
   dollarSchema: z.string().optional(),
+  apps: z.record(V1BadgeApp$outboundSchema),
+  setCounts: V1BadgeSetCounts$outboundSchema,
+  sets: z.nullable(z.array(V1BadgeSet$outboundSchema)),
+  total: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
     dollarSchema: "$schema",