@steamsets/client-ts 0.19.5 → 0.22.3

package/src/funcs/{badgesTag.ts → badgeTag.ts}

@@ -25,7 +25,7 @@ import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
-export function badgesTag(
+export function badgeTag(
   client: SteamSetsCore,
   request: components.V1BadgeTagRequestBody,
   options?: RequestOptions,

package/src/funcs/{leaderboardGetBadges.ts → leaderboardBadgesGetList.ts}

@@ -22,7 +22,7 @@ import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
-export function leaderboardGetBadges(
+export function leaderboardBadgesGetList(
   client: SteamSetsCore,
   options?: RequestOptions,
 ): APIPromise<

package/src/funcs/{leaderboardLeaderboardV1GetLeaderboardAccountMeta.ts → leaderboardGetAccountMeta.ts}

@@ -25,7 +25,7 @@ import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
-export function leaderboardLeaderboardV1GetLeaderboardAccountMeta(
+export function leaderboardGetAccountMeta(
   client: SteamSetsCore,
   request: components.V1LeaderboardAccountMetaRequestBody,
   options?: RequestOptions,

package/src/funcs/{livenessCheck.ts → livenessGet.ts}

@@ -28,7 +28,7 @@ import { Result } from "../types/fp.js";
  * @remarks
  * This endpoint checks if the service is alive.
  */
-export function livenessCheck(
+export function livenessGet(
   client: SteamSetsCore,
   options?: RequestOptions,
 ): APIPromise<

package/src/funcs/{locationsGet.ts → locationGet.ts}

@@ -22,7 +22,7 @@ import * as operations from "../models/operations/index.js";
 import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
-export function locationsGet(
+export function locationGet(
   client: SteamSetsCore,
   options?: RequestOptions,
 ): APIPromise<

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.19.5",
-  genVersion: "2.545.4",
+  sdkVersion: "0.22.3",
+  genVersion: "2.548.1",
   userAgent:
-    "speakeasy-sdk/typescript 0.19.5 2.545.4 1.0.0 @steamsets/client-ts",
+    "speakeasy-sdk/typescript 0.22.3 2.548.1 1.0.0 @steamsets/client-ts",
 } as const;

package/src/lib/sdks.ts

@@ -191,14 +191,9 @@ export class ClientSDK {
 
     if (conf.body instanceof ReadableStream) {
       if (!fetchOptions) {
-        fetchOptions = {
-          // @ts-expect-error see https://github.com/node-fetch/node-fetch/issues/1769
-          duplex: "half",
-        };
-      } else {
-        // @ts-expect-error see https://github.com/node-fetch/node-fetch/issues/1769
-        fetchOptions.duplex = "half";
+        fetchOptions = {};
       }
+      Object.assign(fetchOptions, { duplex: "half" });
     }
 
     let input;

package/src/models/components/index.ts

@@ -120,6 +120,8 @@ export * from "./v1livenessresponsebody.js";
 export * from "./v1loginresponsebody.js";
 export * from "./v1reconnectrequestbody.js";
 export * from "./v1reconnectresponsebody.js";
+export * from "./v1refreshsessionbody.js";
+export * from "./v1refreshsessionrequestbody.js";
 export * from "./v1searchrequest.js";
 export * from "./v1stats.js";
 export * from "./v1updateconnectionrequestbody.js";

package/src/models/components/v1loginresponsebody.ts

@@ -21,6 +21,18 @@ export type V1LoginResponseBody = {
    * The name of the account
    */
   name: string;
+  /**
+   * The expiration time of the refresh token
+   */
+  refreshExpiresAt: Date;
+  /**
+   * The refresh token
+   */
+  refreshToken: string;
+  /**
+   * The expiration time of the session token
+   */
+  sessionExpiresAt: Date;
   /**
    * The session token
    */
@@ -40,6 +52,13 @@ export const V1LoginResponseBody$inboundSchema: z.ZodType<
   $schema: z.string().optional(),
   avatar: z.string(),
   name: z.string(),
+  refreshExpiresAt: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  refreshToken: z.string(),
+  sessionExpiresAt: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
   sessionToken: z.string(),
   steamId: z.string(),
 }).transform((v) => {
@@ -53,6 +72,9 @@ export type V1LoginResponseBody$Outbound = {
   $schema?: string | undefined;
   avatar: string;
   name: string;
+  refreshExpiresAt: string;
+  refreshToken: string;
+  sessionExpiresAt: string;
   sessionToken: string;
   steamId: string;
 };
@@ -66,6 +88,9 @@ export const V1LoginResponseBody$outboundSchema: z.ZodType<
   dollarSchema: z.string().optional(),
   avatar: z.string(),
   name: z.string(),
+  refreshExpiresAt: z.date().transform(v => v.toISOString()),
+  refreshToken: z.string(),
+  sessionExpiresAt: z.date().transform(v => v.toISOString()),
   sessionToken: z.string(),
   steamId: z.string(),
 }).transform((v) => {

package/src/models/components/v1refreshsessionbody.ts

@@ -0,0 +1,110 @@
+/*
+ * 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 V1RefreshSessionBody = {
+  /**
+   * A URL to the JSON Schema for this object.
+   */
+  dollarSchema?: string | undefined;
+  /**
+   * The expiration time of the refresh token
+   */
+  refreshExpiresAt: Date;
+  /**
+   * The refresh token
+   */
+  refreshToken: string;
+  /**
+   * The expiration time of the session token
+   */
+  sessionExpiresAt: Date;
+  /**
+   * The session token
+   */
+  sessionToken: string;
+};
+
+/** @internal */
+export const V1RefreshSessionBody$inboundSchema: z.ZodType<
+  V1RefreshSessionBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  $schema: z.string().optional(),
+  refreshExpiresAt: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  refreshToken: z.string(),
+  sessionExpiresAt: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  sessionToken: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "$schema": "dollarSchema",
+  });
+});
+
+/** @internal */
+export type V1RefreshSessionBody$Outbound = {
+  $schema?: string | undefined;
+  refreshExpiresAt: string;
+  refreshToken: string;
+  sessionExpiresAt: string;
+  sessionToken: string;
+};
+
+/** @internal */
+export const V1RefreshSessionBody$outboundSchema: z.ZodType<
+  V1RefreshSessionBody$Outbound,
+  z.ZodTypeDef,
+  V1RefreshSessionBody
+> = z.object({
+  dollarSchema: z.string().optional(),
+  refreshExpiresAt: z.date().transform(v => v.toISOString()),
+  refreshToken: z.string(),
+  sessionExpiresAt: z.date().transform(v => v.toISOString()),
+  sessionToken: z.string(),
+}).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 V1RefreshSessionBody$ {
+  /** @deprecated use `V1RefreshSessionBody$inboundSchema` instead. */
+  export const inboundSchema = V1RefreshSessionBody$inboundSchema;
+  /** @deprecated use `V1RefreshSessionBody$outboundSchema` instead. */
+  export const outboundSchema = V1RefreshSessionBody$outboundSchema;
+  /** @deprecated use `V1RefreshSessionBody$Outbound` instead. */
+  export type Outbound = V1RefreshSessionBody$Outbound;
+}
+
+export function v1RefreshSessionBodyToJSON(
+  v1RefreshSessionBody: V1RefreshSessionBody,
+): string {
+  return JSON.stringify(
+    V1RefreshSessionBody$outboundSchema.parse(v1RefreshSessionBody),
+  );
+}
+
+export function v1RefreshSessionBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1RefreshSessionBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1RefreshSessionBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1RefreshSessionBody' from JSON`,
+  );
+}

package/src/models/components/v1refreshsessionrequestbody.ts

@@ -0,0 +1,71 @@
+/*
+ * 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 V1RefreshSessionRequestBody = {
+  /**
+   * The refresh token
+   */
+  refreshToken: string;
+};
+
+/** @internal */
+export const V1RefreshSessionRequestBody$inboundSchema: z.ZodType<
+  V1RefreshSessionRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  refreshToken: z.string(),
+});
+
+/** @internal */
+export type V1RefreshSessionRequestBody$Outbound = {
+  refreshToken: string;
+};
+
+/** @internal */
+export const V1RefreshSessionRequestBody$outboundSchema: z.ZodType<
+  V1RefreshSessionRequestBody$Outbound,
+  z.ZodTypeDef,
+  V1RefreshSessionRequestBody
+> = z.object({
+  refreshToken: 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 V1RefreshSessionRequestBody$ {
+  /** @deprecated use `V1RefreshSessionRequestBody$inboundSchema` instead. */
+  export const inboundSchema = V1RefreshSessionRequestBody$inboundSchema;
+  /** @deprecated use `V1RefreshSessionRequestBody$outboundSchema` instead. */
+  export const outboundSchema = V1RefreshSessionRequestBody$outboundSchema;
+  /** @deprecated use `V1RefreshSessionRequestBody$Outbound` instead. */
+  export type Outbound = V1RefreshSessionRequestBody$Outbound;
+}
+
+export function v1RefreshSessionRequestBodyToJSON(
+  v1RefreshSessionRequestBody: V1RefreshSessionRequestBody,
+): string {
+  return JSON.stringify(
+    V1RefreshSessionRequestBody$outboundSchema.parse(
+      v1RefreshSessionRequestBody,
+    ),
+  );
+}
+
+export function v1RefreshSessionRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1RefreshSessionRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1RefreshSessionRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1RefreshSessionRequestBody' from JSON`,
+  );
+}

package/src/models/operations/accountv1sessionlogout.ts

@@ -0,0 +1,78 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AccountV1SessionLogoutResponse = {
+  httpMeta: components.HTTPMetadata;
+};
+
+/** @internal */
+export const AccountV1SessionLogoutResponse$inboundSchema: z.ZodType<
+  AccountV1SessionLogoutResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+  });
+});
+
+/** @internal */
+export type AccountV1SessionLogoutResponse$Outbound = {
+  HttpMeta: components.HTTPMetadata$Outbound;
+};
+
+/** @internal */
+export const AccountV1SessionLogoutResponse$outboundSchema: z.ZodType<
+  AccountV1SessionLogoutResponse$Outbound,
+  z.ZodTypeDef,
+  AccountV1SessionLogoutResponse
+> = z.object({
+  httpMeta: components.HTTPMetadata$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    httpMeta: "HttpMeta",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1SessionLogoutResponse$ {
+  /** @deprecated use `AccountV1SessionLogoutResponse$inboundSchema` instead. */
+  export const inboundSchema = AccountV1SessionLogoutResponse$inboundSchema;
+  /** @deprecated use `AccountV1SessionLogoutResponse$outboundSchema` instead. */
+  export const outboundSchema = AccountV1SessionLogoutResponse$outboundSchema;
+  /** @deprecated use `AccountV1SessionLogoutResponse$Outbound` instead. */
+  export type Outbound = AccountV1SessionLogoutResponse$Outbound;
+}
+
+export function accountV1SessionLogoutResponseToJSON(
+  accountV1SessionLogoutResponse: AccountV1SessionLogoutResponse,
+): string {
+  return JSON.stringify(
+    AccountV1SessionLogoutResponse$outboundSchema.parse(
+      accountV1SessionLogoutResponse,
+    ),
+  );
+}
+
+export function accountV1SessionLogoutResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountV1SessionLogoutResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountV1SessionLogoutResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountV1SessionLogoutResponse' from JSON`,
+  );
+}

package/src/models/operations/accountv1sessionrefresh.ts

@@ -0,0 +1,171 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AccountV1SessionRefreshRequest = {
+  userAgent?: string | undefined;
+  xForwardedFor?: string | undefined;
+  v1RefreshSessionRequestBody: components.V1RefreshSessionRequestBody;
+};
+
+export type AccountV1SessionRefreshResponse = {
+  httpMeta: components.HTTPMetadata;
+  /**
+   * OK
+   */
+  v1RefreshSessionBody?: components.V1RefreshSessionBody | undefined;
+};
+
+/** @internal */
+export const AccountV1SessionRefreshRequest$inboundSchema: z.ZodType<
+  AccountV1SessionRefreshRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "User-Agent": z.string().optional(),
+  "X-Forwarded-For": z.string().optional(),
+  V1RefreshSessionRequestBody:
+    components.V1RefreshSessionRequestBody$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "User-Agent": "userAgent",
+    "X-Forwarded-For": "xForwardedFor",
+    "V1RefreshSessionRequestBody": "v1RefreshSessionRequestBody",
+  });
+});
+
+/** @internal */
+export type AccountV1SessionRefreshRequest$Outbound = {
+  "User-Agent"?: string | undefined;
+  "X-Forwarded-For"?: string | undefined;
+  V1RefreshSessionRequestBody: components.V1RefreshSessionRequestBody$Outbound;
+};
+
+/** @internal */
+export const AccountV1SessionRefreshRequest$outboundSchema: z.ZodType<
+  AccountV1SessionRefreshRequest$Outbound,
+  z.ZodTypeDef,
+  AccountV1SessionRefreshRequest
+> = z.object({
+  userAgent: z.string().optional(),
+  xForwardedFor: z.string().optional(),
+  v1RefreshSessionRequestBody:
+    components.V1RefreshSessionRequestBody$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    userAgent: "User-Agent",
+    xForwardedFor: "X-Forwarded-For",
+    v1RefreshSessionRequestBody: "V1RefreshSessionRequestBody",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1SessionRefreshRequest$ {
+  /** @deprecated use `AccountV1SessionRefreshRequest$inboundSchema` instead. */
+  export const inboundSchema = AccountV1SessionRefreshRequest$inboundSchema;
+  /** @deprecated use `AccountV1SessionRefreshRequest$outboundSchema` instead. */
+  export const outboundSchema = AccountV1SessionRefreshRequest$outboundSchema;
+  /** @deprecated use `AccountV1SessionRefreshRequest$Outbound` instead. */
+  export type Outbound = AccountV1SessionRefreshRequest$Outbound;
+}
+
+export function accountV1SessionRefreshRequestToJSON(
+  accountV1SessionRefreshRequest: AccountV1SessionRefreshRequest,
+): string {
+  return JSON.stringify(
+    AccountV1SessionRefreshRequest$outboundSchema.parse(
+      accountV1SessionRefreshRequest,
+    ),
+  );
+}
+
+export function accountV1SessionRefreshRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountV1SessionRefreshRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountV1SessionRefreshRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountV1SessionRefreshRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const AccountV1SessionRefreshResponse$inboundSchema: z.ZodType<
+  AccountV1SessionRefreshResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  HttpMeta: components.HTTPMetadata$inboundSchema,
+  V1RefreshSessionBody: components.V1RefreshSessionBody$inboundSchema
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "HttpMeta": "httpMeta",
+    "V1RefreshSessionBody": "v1RefreshSessionBody",
+  });
+});
+
+/** @internal */
+export type AccountV1SessionRefreshResponse$Outbound = {
+  HttpMeta: components.HTTPMetadata$Outbound;
+  V1RefreshSessionBody?: components.V1RefreshSessionBody$Outbound | undefined;
+};
+
+/** @internal */
+export const AccountV1SessionRefreshResponse$outboundSchema: z.ZodType<
+  AccountV1SessionRefreshResponse$Outbound,
+  z.ZodTypeDef,
+  AccountV1SessionRefreshResponse
+> = z.object({
+  httpMeta: components.HTTPMetadata$outboundSchema,
+  v1RefreshSessionBody: components.V1RefreshSessionBody$outboundSchema
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    httpMeta: "HttpMeta",
+    v1RefreshSessionBody: "V1RefreshSessionBody",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1SessionRefreshResponse$ {
+  /** @deprecated use `AccountV1SessionRefreshResponse$inboundSchema` instead. */
+  export const inboundSchema = AccountV1SessionRefreshResponse$inboundSchema;
+  /** @deprecated use `AccountV1SessionRefreshResponse$outboundSchema` instead. */
+  export const outboundSchema = AccountV1SessionRefreshResponse$outboundSchema;
+  /** @deprecated use `AccountV1SessionRefreshResponse$Outbound` instead. */
+  export type Outbound = AccountV1SessionRefreshResponse$Outbound;
+}
+
+export function accountV1SessionRefreshResponseToJSON(
+  accountV1SessionRefreshResponse: AccountV1SessionRefreshResponse,
+): string {
+  return JSON.stringify(
+    AccountV1SessionRefreshResponse$outboundSchema.parse(
+      accountV1SessionRefreshResponse,
+    ),
+  );
+}
+
+export function accountV1SessionRefreshResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AccountV1SessionRefreshResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AccountV1SessionRefreshResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AccountV1SessionRefreshResponse' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -27,6 +27,8 @@ export * from "./accountv1sessioncreate.js";
 export * from "./accountv1sessiondelete.js";
 export * from "./accountv1sessionget.js";
 export * from "./accountv1sessionlogin.js";
+export * from "./accountv1sessionlogout.js";
+export * from "./accountv1sessionrefresh.js";
 export * from "./accountv1settingsdeveloperappcreate.js";
 export * from "./accountv1settingsdeveloperappdelete.js";
 export * from "./accountv1settingsdeveloperappupdate.js";