@steamsets/client-ts 0.13.5 → 0.13.7

package/src/funcs/{badgeBadgeV1Bookmark.ts → badgeAccountV1BookmarkBadge.ts}

@@ -23,13 +23,13 @@ import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
 import { Result } from "../types/fp.js";
 
-export async function badgeBadgeV1Bookmark(
+export async function badgeAccountV1BookmarkBadge(
   client: SteamSetsCore,
-  request: components.V1BadgeBookmarkRequestBody,
+  request: components.V1AccountBadgeBookmarkRequestBody,
   options?: RequestOptions,
 ): Promise<
   Result<
-    operations.BadgeV1BookmarkResponse,
+    operations.AccountV1BookmarkBadgeResponse,
     | errors.ErrorModel
     | SDKError
     | SDKValidationError
@@ -43,7 +43,7 @@ export async function badgeBadgeV1Bookmark(
   const parsed = safeParse(
     request,
     (value) =>
-      components.V1BadgeBookmarkRequestBody$outboundSchema.parse(value),
+      components.V1AccountBadgeBookmarkRequestBody$outboundSchema.parse(value),
     "Input validation failed",
   );
   if (!parsed.ok) {
@@ -52,7 +52,7 @@ export async function badgeBadgeV1Bookmark(
   const payload = parsed.value;
   const body = encodeJSON("body", payload, { explode: true });
 
-  const path = pathToFunc("/badge.v1.BadgeService/Bookmark")();
+  const path = pathToFunc("/account.v1.AccountService/BookmarkBadge")();
 
   const headers = new Headers({
     "Content-Type": "application/json",
@@ -64,7 +64,7 @@ export async function badgeBadgeV1Bookmark(
   const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const context = {
-    operationID: "badge.v1.bookmark",
+    operationID: "account.v1.bookmark-badge",
     oAuth2Scopes: [],
 
     resolvedSecurity: requestSecurity,
@@ -116,7 +116,7 @@ export async function badgeBadgeV1Bookmark(
   };
 
   const [result] = await M.match<
-    operations.BadgeV1BookmarkResponse,
+    operations.AccountV1BookmarkBadgeResponse,
     | errors.ErrorModel
     | SDKError
     | SDKValidationError
@@ -126,8 +126,8 @@ export async function badgeBadgeV1Bookmark(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.BadgeV1BookmarkResponse$inboundSchema, {
-      key: "V1BadgeBookmarkResponseBody",
+    M.json(200, operations.AccountV1BookmarkBadgeResponse$inboundSchema, {
+      key: "V1AccountBadgeBookmarkResponseBody",
     }),
     M.jsonErr([403, 404, 422, 500], errors.ErrorModel$inboundSchema, {
       ctype: "application/problem+json",

package/src/funcs/{badgeBadgeV1GetBookmarks.ts → badgeAccountV1GetBadgeBookmarks.ts}

@@ -21,13 +21,13 @@ import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
 import { Result } from "../types/fp.js";
 
-export async function badgeBadgeV1GetBookmarks(
+export async function badgeAccountV1GetBadgeBookmarks(
   client: SteamSetsCore,
-  _request: components.V1GetBadgeBookmarksRequestBody,
+  _request: components.V1AccountBadgeBookmarksRequestBody,
   options?: RequestOptions,
 ): Promise<
   Result<
-    operations.BadgeV1GetBookmarksResponse,
+    operations.AccountV1GetBadgeBookmarksResponse,
     | errors.ErrorModel
     | SDKError
     | SDKValidationError
@@ -38,7 +38,7 @@ export async function badgeBadgeV1GetBookmarks(
     | ConnectionError
   >
 > {
-  const path = pathToFunc("/badge.v1.BadgeService/GetBookmarks")();
+  const path = pathToFunc("/account.v1.AccountService/GetBadgeBookmarks")();
 
   const headers = new Headers({
     "Content-Type": "application/json",
@@ -50,7 +50,7 @@ export async function badgeBadgeV1GetBookmarks(
   const requestSecurity = resolveGlobalSecurity(securityInput);
 
   const context = {
-    operationID: "badge.v1.getBookmarks",
+    operationID: "account.v1.getBadgeBookmarks",
     oAuth2Scopes: [],
 
     resolvedSecurity: requestSecurity,
@@ -101,7 +101,7 @@ export async function badgeBadgeV1GetBookmarks(
   };
 
   const [result] = await M.match<
-    operations.BadgeV1GetBookmarksResponse,
+    operations.AccountV1GetBadgeBookmarksResponse,
     | errors.ErrorModel
     | SDKError
     | SDKValidationError
@@ -111,8 +111,8 @@ export async function badgeBadgeV1GetBookmarks(
     | RequestTimeoutError
     | ConnectionError
   >(
-    M.json(200, operations.BadgeV1GetBookmarksResponse$inboundSchema, {
-      key: "V1GetBadgeBookmarksResponseBody",
+    M.json(200, operations.AccountV1GetBadgeBookmarksResponse$inboundSchema, {
+      key: "V1AccountBadgeBookmarksResponseBody",
     }),
     M.jsonErr([403, 404, 422, 500], errors.ErrorModel$inboundSchema, {
       ctype: "application/problem+json",

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.13.7",
+  genVersion: "2.461.4",
   userAgent:
-    "speakeasy-sdk/typescript 0.13.5 2.461.2 1.0.0 @steamsets/client-ts",
+    "speakeasy-sdk/typescript 0.13.7 2.461.4 1.0.0 @steamsets/client-ts",
 } as const;

package/src/models/components/index.ts

@@ -35,6 +35,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 +53,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 +84,6 @@ 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 "./v1getsessionbody.js";
 export * from "./v1getsettingsbody.js";
 export * from "./v1groupleaderboardgroup.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`,
+  );
+}

package/src/models/components/v1accountbadgebookmarksrequestbody.ts

@@ -0,0 +1,62 @@
+/*
+ * 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 V1AccountBadgeBookmarksRequestBody = {};
+
+/** @internal */
+export const V1AccountBadgeBookmarksRequestBody$inboundSchema: z.ZodType<
+  V1AccountBadgeBookmarksRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+
+/** @internal */
+export type V1AccountBadgeBookmarksRequestBody$Outbound = {};
+
+/** @internal */
+export const V1AccountBadgeBookmarksRequestBody$outboundSchema: z.ZodType<
+  V1AccountBadgeBookmarksRequestBody$Outbound,
+  z.ZodTypeDef,
+  V1AccountBadgeBookmarksRequestBody
+> = 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 V1AccountBadgeBookmarksRequestBody$ {
+  /** @deprecated use `V1AccountBadgeBookmarksRequestBody$inboundSchema` instead. */
+  export const inboundSchema = V1AccountBadgeBookmarksRequestBody$inboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarksRequestBody$outboundSchema` instead. */
+  export const outboundSchema =
+    V1AccountBadgeBookmarksRequestBody$outboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarksRequestBody$Outbound` instead. */
+  export type Outbound = V1AccountBadgeBookmarksRequestBody$Outbound;
+}
+
+export function v1AccountBadgeBookmarksRequestBodyToJSON(
+  v1AccountBadgeBookmarksRequestBody: V1AccountBadgeBookmarksRequestBody,
+): string {
+  return JSON.stringify(
+    V1AccountBadgeBookmarksRequestBody$outboundSchema.parse(
+      v1AccountBadgeBookmarksRequestBody,
+    ),
+  );
+}
+
+export function v1AccountBadgeBookmarksRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountBadgeBookmarksRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      V1AccountBadgeBookmarksRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountBadgeBookmarksRequestBody' from JSON`,
+  );
+}

package/src/models/components/v1accountbadgebookmarksresponsebody.ts

@@ -0,0 +1,93 @@
+/*
+ * 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 {
+  V1AccountBadgeBookmark,
+  V1AccountBadgeBookmark$inboundSchema,
+  V1AccountBadgeBookmark$Outbound,
+  V1AccountBadgeBookmark$outboundSchema,
+} from "./v1accountbadgebookmark.js";
+
+export type V1AccountBadgeBookmarksResponseBody = {
+  /**
+   * A URL to the JSON Schema for this object.
+   */
+  dollarSchema?: string | undefined;
+  bookmarks: Array<V1AccountBadgeBookmark> | null;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmarksResponseBody$inboundSchema: z.ZodType<
+  V1AccountBadgeBookmarksResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  $schema: z.string().optional(),
+  bookmarks: z.nullable(z.array(V1AccountBadgeBookmark$inboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    "$schema": "dollarSchema",
+  });
+});
+
+/** @internal */
+export type V1AccountBadgeBookmarksResponseBody$Outbound = {
+  $schema?: string | undefined;
+  bookmarks: Array<V1AccountBadgeBookmark$Outbound> | null;
+};
+
+/** @internal */
+export const V1AccountBadgeBookmarksResponseBody$outboundSchema: z.ZodType<
+  V1AccountBadgeBookmarksResponseBody$Outbound,
+  z.ZodTypeDef,
+  V1AccountBadgeBookmarksResponseBody
+> = z.object({
+  dollarSchema: z.string().optional(),
+  bookmarks: z.nullable(z.array(V1AccountBadgeBookmark$outboundSchema)),
+}).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 V1AccountBadgeBookmarksResponseBody$ {
+  /** @deprecated use `V1AccountBadgeBookmarksResponseBody$inboundSchema` instead. */
+  export const inboundSchema =
+    V1AccountBadgeBookmarksResponseBody$inboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarksResponseBody$outboundSchema` instead. */
+  export const outboundSchema =
+    V1AccountBadgeBookmarksResponseBody$outboundSchema;
+  /** @deprecated use `V1AccountBadgeBookmarksResponseBody$Outbound` instead. */
+  export type Outbound = V1AccountBadgeBookmarksResponseBody$Outbound;
+}
+
+export function v1AccountBadgeBookmarksResponseBodyToJSON(
+  v1AccountBadgeBookmarksResponseBody: V1AccountBadgeBookmarksResponseBody,
+): string {
+  return JSON.stringify(
+    V1AccountBadgeBookmarksResponseBody$outboundSchema.parse(
+      v1AccountBadgeBookmarksResponseBody,
+    ),
+  );
+}
+
+export function v1AccountBadgeBookmarksResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountBadgeBookmarksResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      V1AccountBadgeBookmarksResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountBadgeBookmarksResponseBody' from JSON`,
+  );
+}

package/src/models/components/v1accountlocationupdate.ts

@@ -0,0 +1,104 @@
+/*
+ * 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 V1AccountLocationUpdate = {
+  /**
+   * The city name of the location
+   */
+  city: string | null;
+  /**
+   * The country code of the location
+   */
+  countryCode: string | null;
+  /**
+   * The country name of the location
+   */
+  countryName: string | null;
+  /**
+   * The region name of the location
+   */
+  region: string | null;
+  /**
+   * The state name of the location
+   */
+  state: string | null;
+  /**
+   * The time the location was updated
+   */
+  updatedAt: Date;
+};
+
+/** @internal */
+export const V1AccountLocationUpdate$inboundSchema: z.ZodType<
+  V1AccountLocationUpdate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  city: z.nullable(z.string()),
+  countryCode: z.nullable(z.string()),
+  countryName: z.nullable(z.string()),
+  region: z.nullable(z.string()),
+  state: z.nullable(z.string()),
+  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+});
+
+/** @internal */
+export type V1AccountLocationUpdate$Outbound = {
+  city: string | null;
+  countryCode: string | null;
+  countryName: string | null;
+  region: string | null;
+  state: string | null;
+  updatedAt: string;
+};
+
+/** @internal */
+export const V1AccountLocationUpdate$outboundSchema: z.ZodType<
+  V1AccountLocationUpdate$Outbound,
+  z.ZodTypeDef,
+  V1AccountLocationUpdate
+> = z.object({
+  city: z.nullable(z.string()),
+  countryCode: z.nullable(z.string()),
+  countryName: z.nullable(z.string()),
+  region: z.nullable(z.string()),
+  state: z.nullable(z.string()),
+  updatedAt: 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 V1AccountLocationUpdate$ {
+  /** @deprecated use `V1AccountLocationUpdate$inboundSchema` instead. */
+  export const inboundSchema = V1AccountLocationUpdate$inboundSchema;
+  /** @deprecated use `V1AccountLocationUpdate$outboundSchema` instead. */
+  export const outboundSchema = V1AccountLocationUpdate$outboundSchema;
+  /** @deprecated use `V1AccountLocationUpdate$Outbound` instead. */
+  export type Outbound = V1AccountLocationUpdate$Outbound;
+}
+
+export function v1AccountLocationUpdateToJSON(
+  v1AccountLocationUpdate: V1AccountLocationUpdate,
+): string {
+  return JSON.stringify(
+    V1AccountLocationUpdate$outboundSchema.parse(v1AccountLocationUpdate),
+  );
+}
+
+export function v1AccountLocationUpdateFromJSON(
+  jsonString: string,
+): SafeParseResult<V1AccountLocationUpdate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => V1AccountLocationUpdate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'V1AccountLocationUpdate' from JSON`,
+  );
+}