latitudesh-typescript-sdk 0.8.2 → 0.8.3

package/src/models/outofbandconnection.ts

@@ -8,7 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
-export type SshKey = {
+export type OutOfBandConnectionSshKey = {
   id?: string | undefined;
   description?: string | undefined;
   fingerprint?: string | undefined;
@@ -23,7 +23,7 @@ export type OutOfBandConnectionCredentials = {
 };
 
 export type OutOfBandConnectionAttributes = {
-  sshKey?: SshKey | undefined;
+  sshKey?: OutOfBandConnectionSshKey | undefined;
   createdAt?: string | undefined;
   username?: string | undefined;
   /**
@@ -47,40 +47,47 @@ export type OutOfBandConnection = {
 };
 
 /** @internal */
-export const SshKey$inboundSchema: z.ZodType<SshKey, z.ZodTypeDef, unknown> = z
-  .object({
-    id: z.string().optional(),
-    description: z.string().optional(),
-    fingerprint: z.string().optional(),
-  });
+export const OutOfBandConnectionSshKey$inboundSchema: z.ZodType<
+  OutOfBandConnectionSshKey,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  description: z.string().optional(),
+  fingerprint: z.string().optional(),
+});
 /** @internal */
-export type SshKey$Outbound = {
+export type OutOfBandConnectionSshKey$Outbound = {
   id?: string | undefined;
   description?: string | undefined;
   fingerprint?: string | undefined;
 };
 
 /** @internal */
-export const SshKey$outboundSchema: z.ZodType<
-  SshKey$Outbound,
+export const OutOfBandConnectionSshKey$outboundSchema: z.ZodType<
+  OutOfBandConnectionSshKey$Outbound,
   z.ZodTypeDef,
-  SshKey
+  OutOfBandConnectionSshKey
 > = z.object({
   id: z.string().optional(),
   description: z.string().optional(),
   fingerprint: z.string().optional(),
 });
 
-export function sshKeyToJSON(sshKey: SshKey): string {
-  return JSON.stringify(SshKey$outboundSchema.parse(sshKey));
+export function outOfBandConnectionSshKeyToJSON(
+  outOfBandConnectionSshKey: OutOfBandConnectionSshKey,
+): string {
+  return JSON.stringify(
+    OutOfBandConnectionSshKey$outboundSchema.parse(outOfBandConnectionSshKey),
+  );
 }
-export function sshKeyFromJSON(
+export function outOfBandConnectionSshKeyFromJSON(
   jsonString: string,
-): SafeParseResult<SshKey, SDKValidationError> {
+): SafeParseResult<OutOfBandConnectionSshKey, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => SshKey$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SshKey' from JSON`,
+    (x) => OutOfBandConnectionSshKey$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OutOfBandConnectionSshKey' from JSON`,
   );
 }
 
@@ -134,7 +141,7 @@ export const OutOfBandConnectionAttributes$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  ssh_key: z.lazy(() => SshKey$inboundSchema).optional(),
+  ssh_key: z.lazy(() => OutOfBandConnectionSshKey$inboundSchema).optional(),
   created_at: z.string().optional(),
   username: z.string().optional(),
   credentials: z.lazy(() => OutOfBandConnectionCredentials$inboundSchema)
@@ -153,7 +160,7 @@ export const OutOfBandConnectionAttributes$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type OutOfBandConnectionAttributes$Outbound = {
-  ssh_key?: SshKey$Outbound | undefined;
+  ssh_key?: OutOfBandConnectionSshKey$Outbound | undefined;
   created_at?: string | undefined;
   username?: string | undefined;
   credentials?: OutOfBandConnectionCredentials$Outbound | undefined;
@@ -169,7 +176,7 @@ export const OutOfBandConnectionAttributes$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OutOfBandConnectionAttributes
 > = z.object({
-  sshKey: z.lazy(() => SshKey$outboundSchema).optional(),
+  sshKey: z.lazy(() => OutOfBandConnectionSshKey$outboundSchema).optional(),
   createdAt: z.string().optional(),
   username: z.string().optional(),
   credentials: z.lazy(() => OutOfBandConnectionCredentials$outboundSchema)

package/src/models/storageplandata.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
@@ -13,16 +14,46 @@ export const StoragePlanDataType = {
 } as const;
 export type StoragePlanDataType = ClosedEnum<typeof StoragePlanDataType>;
 
-export type StoragePlanDataPricing = {
+export const StoragePlanStorageType = {
+  Filesystem: "filesystem",
+  Object: "object",
+} as const;
+export type StoragePlanStorageType = ClosedEnum<typeof StoragePlanStorageType>;
+
+export const StoragePlanStorageClass = {
+  Standard: "standard",
+  HighPerformance: "high_performance",
+} as const;
+export type StoragePlanStorageClass = ClosedEnum<
+  typeof StoragePlanStorageClass
+>;
+
+export type StoragePlanDataUSD = {
   month?: number | undefined;
 };
 
-export type StoragePlanDataAttributes = {
+export type StoragePlanDataBRL = {
+  month?: number | undefined;
+};
+
+export type StoragePlanDataPricing = {
+  usd?: StoragePlanDataUSD | undefined;
+  brl?: StoragePlanDataBRL | undefined;
+};
+
+export type StoragePlanDataRegion = {
   name?: string | undefined;
   locations?: Array<string> | undefined;
   pricing?: StoragePlanDataPricing | undefined;
 };
 
+export type StoragePlanDataAttributes = {
+  name?: string | undefined;
+  storagePlanStorageType?: StoragePlanStorageType | undefined;
+  storagePlanStorageClass?: StoragePlanStorageClass | null | undefined;
+  regions?: Array<StoragePlanDataRegion> | undefined;
+};
+
 export type StoragePlanData = {
   id?: string | undefined;
   type?: StoragePlanDataType | undefined;
@@ -38,17 +69,120 @@ export const StoragePlanDataType$outboundSchema: z.ZodNativeEnum<
   typeof StoragePlanDataType
 > = StoragePlanDataType$inboundSchema;
 
+/** @internal */
+export const StoragePlanStorageType$inboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageType
+> = z.nativeEnum(StoragePlanStorageType);
+/** @internal */
+export const StoragePlanStorageType$outboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageType
+> = StoragePlanStorageType$inboundSchema;
+
+/** @internal */
+export const StoragePlanStorageClass$inboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageClass
+> = z.nativeEnum(StoragePlanStorageClass);
+/** @internal */
+export const StoragePlanStorageClass$outboundSchema: z.ZodNativeEnum<
+  typeof StoragePlanStorageClass
+> = StoragePlanStorageClass$inboundSchema;
+
+/** @internal */
+export const StoragePlanDataUSD$inboundSchema: z.ZodType<
+  StoragePlanDataUSD,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  month: z.number().optional(),
+});
+/** @internal */
+export type StoragePlanDataUSD$Outbound = {
+  month?: number | undefined;
+};
+
+/** @internal */
+export const StoragePlanDataUSD$outboundSchema: z.ZodType<
+  StoragePlanDataUSD$Outbound,
+  z.ZodTypeDef,
+  StoragePlanDataUSD
+> = z.object({
+  month: z.number().optional(),
+});
+
+export function storagePlanDataUSDToJSON(
+  storagePlanDataUSD: StoragePlanDataUSD,
+): string {
+  return JSON.stringify(
+    StoragePlanDataUSD$outboundSchema.parse(storagePlanDataUSD),
+  );
+}
+export function storagePlanDataUSDFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePlanDataUSD, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePlanDataUSD$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePlanDataUSD' from JSON`,
+  );
+}
+
+/** @internal */
+export const StoragePlanDataBRL$inboundSchema: z.ZodType<
+  StoragePlanDataBRL,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  month: z.number().optional(),
+});
+/** @internal */
+export type StoragePlanDataBRL$Outbound = {
+  month?: number | undefined;
+};
+
+/** @internal */
+export const StoragePlanDataBRL$outboundSchema: z.ZodType<
+  StoragePlanDataBRL$Outbound,
+  z.ZodTypeDef,
+  StoragePlanDataBRL
+> = z.object({
+  month: z.number().optional(),
+});
+
+export function storagePlanDataBRLToJSON(
+  storagePlanDataBRL: StoragePlanDataBRL,
+): string {
+  return JSON.stringify(
+    StoragePlanDataBRL$outboundSchema.parse(storagePlanDataBRL),
+  );
+}
+export function storagePlanDataBRLFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePlanDataBRL, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePlanDataBRL$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePlanDataBRL' from JSON`,
+  );
+}
+
 /** @internal */
 export const StoragePlanDataPricing$inboundSchema: z.ZodType<
   StoragePlanDataPricing,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  month: z.number().optional(),
+  USD: z.lazy(() => StoragePlanDataUSD$inboundSchema).optional(),
+  BRL: z.lazy(() => StoragePlanDataBRL$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "USD": "usd",
+    "BRL": "brl",
+  });
 });
 /** @internal */
 export type StoragePlanDataPricing$Outbound = {
-  month?: number | undefined;
+  USD?: StoragePlanDataUSD$Outbound | undefined;
+  BRL?: StoragePlanDataBRL$Outbound | undefined;
 };
 
 /** @internal */
@@ -57,7 +191,13 @@ export const StoragePlanDataPricing$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   StoragePlanDataPricing
 > = z.object({
-  month: z.number().optional(),
+  usd: z.lazy(() => StoragePlanDataUSD$outboundSchema).optional(),
+  brl: z.lazy(() => StoragePlanDataBRL$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    usd: "USD",
+    brl: "BRL",
+  });
 });
 
 export function storagePlanDataPricingToJSON(
@@ -78,8 +218,8 @@ export function storagePlanDataPricingFromJSON(
 }
 
 /** @internal */
-export const StoragePlanDataAttributes$inboundSchema: z.ZodType<
-  StoragePlanDataAttributes,
+export const StoragePlanDataRegion$inboundSchema: z.ZodType<
+  StoragePlanDataRegion,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -88,12 +228,65 @@ export const StoragePlanDataAttributes$inboundSchema: z.ZodType<
   pricing: z.lazy(() => StoragePlanDataPricing$inboundSchema).optional(),
 });
 /** @internal */
-export type StoragePlanDataAttributes$Outbound = {
+export type StoragePlanDataRegion$Outbound = {
   name?: string | undefined;
   locations?: Array<string> | undefined;
   pricing?: StoragePlanDataPricing$Outbound | undefined;
 };
 
+/** @internal */
+export const StoragePlanDataRegion$outboundSchema: z.ZodType<
+  StoragePlanDataRegion$Outbound,
+  z.ZodTypeDef,
+  StoragePlanDataRegion
+> = z.object({
+  name: z.string().optional(),
+  locations: z.array(z.string()).optional(),
+  pricing: z.lazy(() => StoragePlanDataPricing$outboundSchema).optional(),
+});
+
+export function storagePlanDataRegionToJSON(
+  storagePlanDataRegion: StoragePlanDataRegion,
+): string {
+  return JSON.stringify(
+    StoragePlanDataRegion$outboundSchema.parse(storagePlanDataRegion),
+  );
+}
+export function storagePlanDataRegionFromJSON(
+  jsonString: string,
+): SafeParseResult<StoragePlanDataRegion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StoragePlanDataRegion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StoragePlanDataRegion' from JSON`,
+  );
+}
+
+/** @internal */
+export const StoragePlanDataAttributes$inboundSchema: z.ZodType<
+  StoragePlanDataAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  storage_type: StoragePlanStorageType$inboundSchema.optional(),
+  storage_class: z.nullable(StoragePlanStorageClass$inboundSchema).optional(),
+  regions: z.array(z.lazy(() => StoragePlanDataRegion$inboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "storage_type": "storagePlanStorageType",
+    "storage_class": "storagePlanStorageClass",
+  });
+});
+/** @internal */
+export type StoragePlanDataAttributes$Outbound = {
+  name?: string | undefined;
+  storage_type?: string | undefined;
+  storage_class?: string | null | undefined;
+  regions?: Array<StoragePlanDataRegion$Outbound> | undefined;
+};
+
 /** @internal */
 export const StoragePlanDataAttributes$outboundSchema: z.ZodType<
   StoragePlanDataAttributes$Outbound,
@@ -101,8 +294,16 @@ export const StoragePlanDataAttributes$outboundSchema: z.ZodType<
   StoragePlanDataAttributes
 > = z.object({
   name: z.string().optional(),
-  locations: z.array(z.string()).optional(),
-  pricing: z.lazy(() => StoragePlanDataPricing$outboundSchema).optional(),
+  storagePlanStorageType: StoragePlanStorageType$outboundSchema.optional(),
+  storagePlanStorageClass: z.nullable(StoragePlanStorageClass$outboundSchema)
+    .optional(),
+  regions: z.array(z.lazy(() => StoragePlanDataRegion$outboundSchema))
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    storagePlanStorageType: "storage_type",
+    storagePlanStorageClass: "storage_class",
+  });
 });
 
 export function storagePlanDataAttributesToJSON(

package/src/models/userteam.ts

@@ -5,8 +5,15 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import {
+  ProjectInclude,
+  ProjectInclude$inboundSchema,
+  ProjectInclude$Outbound,
+  ProjectInclude$outboundSchema,
+} from "./projectinclude.js";
 import {
   UserInclude,
   UserInclude$inboundSchema,
@@ -14,11 +21,28 @@ import {
   UserInclude$outboundSchema,
 } from "./userinclude.js";
 
+export const UserTeamType = {
+  Teams: "teams",
+} as const;
+export type UserTeamType = ClosedEnum<typeof UserTeamType>;
+
 export type UserTeamBilling = {
   id?: string | undefined;
   customerBillingId?: string | undefined;
 };
 
+export type UserTeamLimits = {
+  bareMetal?: number | null | undefined;
+  bareMetalGpu?: number | null | undefined;
+  virtualMachine?: number | null | undefined;
+  virtualMachineGpu?: number | null | undefined;
+  elasticIp?: number | null | undefined;
+  virtualNetwork?: number | null | undefined;
+  database?: number | null | undefined;
+  filesystem?: number | null | undefined;
+  blockStorage?: number | null | undefined;
+};
+
 export type UserTeamAttributes = {
   name?: string | undefined;
   slug?: string | undefined;
@@ -27,15 +51,29 @@ export type UserTeamAttributes = {
   currency?: string | undefined;
   createdAt?: string | undefined;
   updatedAt?: string | undefined;
+  status?: string | null | undefined;
+  enforceMfa?: boolean | undefined;
+  users?: Array<UserInclude> | undefined;
+  projects?: Array<ProjectInclude> | undefined;
   owner?: UserInclude | undefined;
   billing?: UserTeamBilling | undefined;
+  featureFlags?: Array<string> | undefined;
+  limits?: UserTeamLimits | undefined;
 };
 
 export type UserTeam = {
   id?: string | undefined;
+  type?: UserTeamType | undefined;
   attributes?: UserTeamAttributes | undefined;
 };
 
+/** @internal */
+export const UserTeamType$inboundSchema: z.ZodNativeEnum<typeof UserTeamType> =
+  z.nativeEnum(UserTeamType);
+/** @internal */
+export const UserTeamType$outboundSchema: z.ZodNativeEnum<typeof UserTeamType> =
+  UserTeamType$inboundSchema;
+
 /** @internal */
 export const UserTeamBilling$inboundSchema: z.ZodType<
   UserTeamBilling,
@@ -84,6 +122,85 @@ export function userTeamBillingFromJSON(
   );
 }
 
+/** @internal */
+export const UserTeamLimits$inboundSchema: z.ZodType<
+  UserTeamLimits,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bare_metal: z.nullable(z.number().int()).optional(),
+  bare_metal_gpu: z.nullable(z.number().int()).optional(),
+  virtual_machine: z.nullable(z.number().int()).optional(),
+  virtual_machine_gpu: z.nullable(z.number().int()).optional(),
+  elastic_ip: z.nullable(z.number().int()).optional(),
+  virtual_network: z.nullable(z.number().int()).optional(),
+  database: z.nullable(z.number().int()).optional(),
+  filesystem: z.nullable(z.number().int()).optional(),
+  block_storage: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "bare_metal": "bareMetal",
+    "bare_metal_gpu": "bareMetalGpu",
+    "virtual_machine": "virtualMachine",
+    "virtual_machine_gpu": "virtualMachineGpu",
+    "elastic_ip": "elasticIp",
+    "virtual_network": "virtualNetwork",
+    "block_storage": "blockStorage",
+  });
+});
+/** @internal */
+export type UserTeamLimits$Outbound = {
+  bare_metal?: number | null | undefined;
+  bare_metal_gpu?: number | null | undefined;
+  virtual_machine?: number | null | undefined;
+  virtual_machine_gpu?: number | null | undefined;
+  elastic_ip?: number | null | undefined;
+  virtual_network?: number | null | undefined;
+  database?: number | null | undefined;
+  filesystem?: number | null | undefined;
+  block_storage?: number | null | undefined;
+};
+
+/** @internal */
+export const UserTeamLimits$outboundSchema: z.ZodType<
+  UserTeamLimits$Outbound,
+  z.ZodTypeDef,
+  UserTeamLimits
+> = z.object({
+  bareMetal: z.nullable(z.number().int()).optional(),
+  bareMetalGpu: z.nullable(z.number().int()).optional(),
+  virtualMachine: z.nullable(z.number().int()).optional(),
+  virtualMachineGpu: z.nullable(z.number().int()).optional(),
+  elasticIp: z.nullable(z.number().int()).optional(),
+  virtualNetwork: z.nullable(z.number().int()).optional(),
+  database: z.nullable(z.number().int()).optional(),
+  filesystem: z.nullable(z.number().int()).optional(),
+  blockStorage: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    bareMetal: "bare_metal",
+    bareMetalGpu: "bare_metal_gpu",
+    virtualMachine: "virtual_machine",
+    virtualMachineGpu: "virtual_machine_gpu",
+    elasticIp: "elastic_ip",
+    virtualNetwork: "virtual_network",
+    blockStorage: "block_storage",
+  });
+});
+
+export function userTeamLimitsToJSON(userTeamLimits: UserTeamLimits): string {
+  return JSON.stringify(UserTeamLimits$outboundSchema.parse(userTeamLimits));
+}
+export function userTeamLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<UserTeamLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserTeamLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserTeamLimits' from JSON`,
+  );
+}
+
 /** @internal */
 export const UserTeamAttributes$inboundSchema: z.ZodType<
   UserTeamAttributes,
@@ -97,12 +214,20 @@ export const UserTeamAttributes$inboundSchema: z.ZodType<
   currency: z.string().optional(),
   created_at: z.string().optional(),
   updated_at: z.string().optional(),
+  status: z.nullable(z.string()).optional(),
+  enforce_mfa: z.boolean().optional(),
+  users: z.array(UserInclude$inboundSchema).optional(),
+  projects: z.array(ProjectInclude$inboundSchema).optional(),
   owner: UserInclude$inboundSchema.optional(),
   billing: z.lazy(() => UserTeamBilling$inboundSchema).optional(),
+  feature_flags: z.array(z.string()).optional(),
+  limits: z.lazy(() => UserTeamLimits$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
     "updated_at": "updatedAt",
+    "enforce_mfa": "enforceMfa",
+    "feature_flags": "featureFlags",
   });
 });
 /** @internal */
@@ -114,8 +239,14 @@ export type UserTeamAttributes$Outbound = {
   currency?: string | undefined;
   created_at?: string | undefined;
   updated_at?: string | undefined;
+  status?: string | null | undefined;
+  enforce_mfa?: boolean | undefined;
+  users?: Array<UserInclude$Outbound> | undefined;
+  projects?: Array<ProjectInclude$Outbound> | undefined;
   owner?: UserInclude$Outbound | undefined;
   billing?: UserTeamBilling$Outbound | undefined;
+  feature_flags?: Array<string> | undefined;
+  limits?: UserTeamLimits$Outbound | undefined;
 };
 
 /** @internal */
@@ -131,12 +262,20 @@ export const UserTeamAttributes$outboundSchema: z.ZodType<
   currency: z.string().optional(),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional(),
+  status: z.nullable(z.string()).optional(),
+  enforceMfa: z.boolean().optional(),
+  users: z.array(UserInclude$outboundSchema).optional(),
+  projects: z.array(ProjectInclude$outboundSchema).optional(),
   owner: UserInclude$outboundSchema.optional(),
   billing: z.lazy(() => UserTeamBilling$outboundSchema).optional(),
+  featureFlags: z.array(z.string()).optional(),
+  limits: z.lazy(() => UserTeamLimits$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",
     updatedAt: "updated_at",
+    enforceMfa: "enforce_mfa",
+    featureFlags: "feature_flags",
   });
 });
 
@@ -164,11 +303,13 @@ export const UserTeam$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
+  type: UserTeamType$inboundSchema.optional(),
   attributes: z.lazy(() => UserTeamAttributes$inboundSchema).optional(),
 });
 /** @internal */
 export type UserTeam$Outbound = {
   id?: string | undefined;
+  type?: string | undefined;
   attributes?: UserTeamAttributes$Outbound | undefined;
 };
 
@@ -179,6 +320,7 @@ export const UserTeam$outboundSchema: z.ZodType<
   UserTeam
 > = z.object({
   id: z.string().optional(),
+  type: UserTeamType$outboundSchema.optional(),
   attributes: z.lazy(() => UserTeamAttributes$outboundSchema).optional(),
 });