latitudesh-typescript-sdk 0.6.0 → 0.6.2

package/src/models/team.ts

@@ -25,6 +25,18 @@ export type TeamBilling = {
   customerBillingId?: string | undefined;
 };
 
+export type TeamLimits = {
+  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 TeamAttributes = {
   name?: string | undefined;
   slug?: string | undefined;
@@ -39,6 +51,7 @@ export type TeamAttributes = {
   owner?: UserInclude | undefined;
   billing?: TeamBilling | undefined;
   featureFlags?: Array<string> | undefined;
+  limits?: TeamLimits | undefined;
 };
 
 export type Team = {
@@ -92,6 +105,85 @@ export function teamBillingFromJSON(
   );
 }
 
+/** @internal */
+export const TeamLimits$inboundSchema: z.ZodType<
+  TeamLimits,
+  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 TeamLimits$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 TeamLimits$outboundSchema: z.ZodType<
+  TeamLimits$Outbound,
+  z.ZodTypeDef,
+  TeamLimits
+> = 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 teamLimitsToJSON(teamLimits: TeamLimits): string {
+  return JSON.stringify(TeamLimits$outboundSchema.parse(teamLimits));
+}
+export function teamLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<TeamLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TeamLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TeamLimits' from JSON`,
+  );
+}
+
 /** @internal */
 export const TeamAttributes$inboundSchema: z.ZodType<
   TeamAttributes,
@@ -111,6 +203,7 @@ export const TeamAttributes$inboundSchema: z.ZodType<
   owner: UserInclude$inboundSchema.optional(),
   billing: z.lazy(() => TeamBilling$inboundSchema).optional(),
   feature_flags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamLimits$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
@@ -134,6 +227,7 @@ export type TeamAttributes$Outbound = {
   owner?: UserInclude$Outbound | undefined;
   billing?: TeamBilling$Outbound | undefined;
   feature_flags?: Array<string> | undefined;
+  limits?: TeamLimits$Outbound | undefined;
 };
 
 /** @internal */
@@ -155,6 +249,7 @@ export const TeamAttributes$outboundSchema: z.ZodType<
   owner: UserInclude$outboundSchema.optional(),
   billing: z.lazy(() => TeamBilling$outboundSchema).optional(),
   featureFlags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamLimits$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",

package/src/models/teaminclude.ts

@@ -10,6 +10,18 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
 export type Currency = {};
 
+export type TeamIncludeLimits = {
+  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 TeamInclude = {
   id?: string | undefined;
   name?: string | undefined;
@@ -19,6 +31,7 @@ export type TeamInclude = {
   currency?: Currency | undefined;
   status?: string | undefined;
   featureFlags?: Array<string> | undefined;
+  limits?: TeamIncludeLimits | undefined;
 };
 
 /** @internal */
@@ -50,6 +63,89 @@ export function currencyFromJSON(
   );
 }
 
+/** @internal */
+export const TeamIncludeLimits$inboundSchema: z.ZodType<
+  TeamIncludeLimits,
+  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 TeamIncludeLimits$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 TeamIncludeLimits$outboundSchema: z.ZodType<
+  TeamIncludeLimits$Outbound,
+  z.ZodTypeDef,
+  TeamIncludeLimits
+> = 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 teamIncludeLimitsToJSON(
+  teamIncludeLimits: TeamIncludeLimits,
+): string {
+  return JSON.stringify(
+    TeamIncludeLimits$outboundSchema.parse(teamIncludeLimits),
+  );
+}
+export function teamIncludeLimitsFromJSON(
+  jsonString: string,
+): SafeParseResult<TeamIncludeLimits, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TeamIncludeLimits$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TeamIncludeLimits' from JSON`,
+  );
+}
+
 /** @internal */
 export const TeamInclude$inboundSchema: z.ZodType<
   TeamInclude,
@@ -64,6 +160,7 @@ export const TeamInclude$inboundSchema: z.ZodType<
   currency: z.lazy(() => Currency$inboundSchema).optional(),
   status: z.string().optional(),
   feature_flags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamIncludeLimits$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "feature_flags": "featureFlags",
@@ -79,6 +176,7 @@ export type TeamInclude$Outbound = {
   currency?: Currency$Outbound | undefined;
   status?: string | undefined;
   feature_flags?: Array<string> | undefined;
+  limits?: TeamIncludeLimits$Outbound | undefined;
 };
 
 /** @internal */
@@ -95,6 +193,7 @@ export const TeamInclude$outboundSchema: z.ZodType<
   currency: z.lazy(() => Currency$outboundSchema).optional(),
   status: z.string().optional(),
   featureFlags: z.array(z.string()).optional(),
+  limits: z.lazy(() => TeamIncludeLimits$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     featureFlags: "feature_flags",

package/src/models/userdata.ts

@@ -13,14 +13,14 @@ import {
   PaginationMeta$outboundSchema,
 } from "./paginationmeta.js";
 import {
-  UserDataObject,
-  UserDataObject$inboundSchema,
-  UserDataObject$Outbound,
-  UserDataObject$outboundSchema,
-} from "./userdataobject.js";
+  UserDataProperties,
+  UserDataProperties$inboundSchema,
+  UserDataProperties$Outbound,
+  UserDataProperties$outboundSchema,
+} from "./userdataproperties.js";
 
 export type UserData = {
-  data?: Array<UserDataObject> | undefined;
+  data?: Array<UserDataProperties> | undefined;
   meta?: PaginationMeta | undefined;
 };
 
@@ -30,12 +30,12 @@ export const UserData$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  data: z.array(UserDataObject$inboundSchema).optional(),
+  data: z.array(UserDataProperties$inboundSchema).optional(),
   meta: PaginationMeta$inboundSchema.optional(),
 });
 /** @internal */
 export type UserData$Outbound = {
-  data?: Array<UserDataObject$Outbound> | undefined;
+  data?: Array<UserDataProperties$Outbound> | undefined;
   meta?: PaginationMeta$Outbound | undefined;
 };
 
@@ -45,7 +45,7 @@ export const UserData$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UserData
 > = z.object({
-  data: z.array(UserDataObject$outboundSchema).optional(),
+  data: z.array(UserDataProperties$outboundSchema).optional(),
   meta: PaginationMeta$outboundSchema.optional(),
 });
 

package/src/models/userdataproperties.ts

@@ -29,6 +29,10 @@ export type UserDataPropertiesAttributes = {
    * content of the User Data
    */
   content?: string | undefined;
+  /**
+   * decoded content of the User Data
+   */
+  decodedContent?: string | null | undefined;
   project?: ProjectInclude | undefined;
   createdAt?: string | undefined;
   updatedAt?: string | undefined;
@@ -57,11 +61,13 @@ export const UserDataPropertiesAttributes$inboundSchema: z.ZodType<
 > = z.object({
   description: z.string().optional(),
   content: z.string().optional(),
+  decoded_content: z.nullable(z.string()).optional(),
   project: ProjectInclude$inboundSchema.optional(),
   created_at: z.string().optional(),
   updated_at: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
+    "decoded_content": "decodedContent",
     "created_at": "createdAt",
     "updated_at": "updatedAt",
   });
@@ -70,6 +76,7 @@ export const UserDataPropertiesAttributes$inboundSchema: z.ZodType<
 export type UserDataPropertiesAttributes$Outbound = {
   description?: string | undefined;
   content?: string | undefined;
+  decoded_content?: string | null | undefined;
   project?: ProjectInclude$Outbound | undefined;
   created_at?: string | undefined;
   updated_at?: string | undefined;
@@ -83,11 +90,13 @@ export const UserDataPropertiesAttributes$outboundSchema: z.ZodType<
 > = z.object({
   description: z.string().optional(),
   content: z.string().optional(),
+  decodedContent: z.nullable(z.string()).optional(),
   project: ProjectInclude$outboundSchema.optional(),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
+    decodedContent: "decoded_content",
     createdAt: "created_at",
     updatedAt: "updated_at",
   });

package/tests/integration/helpers/mock-data.ts

@@ -471,40 +471,34 @@ export const mockUserData = {
 export const mockUserDataList = {
   data: [
     {
-      data: {
-        id: 'userdata_test123',
-        type: 'user_data',
-        attributes: {
-          description: 'Test User Data Script',
-          content: '#!/bin/bash\necho "Hello World"\napt-get update\napt-get install -y nginx',
-          project: {
-            id: 'proj_test123',
-            name: 'Test Project',
-            slug: 'test-project',
-          },
-          created_at: '2024-01-01T00:00:00Z',
-          updated_at: '2024-01-01T00:00:00Z',
+      id: 'userdata_test123',
+      type: 'user_data',
+      attributes: {
+        description: 'Test User Data Script',
+        content: '#!/bin/bash\necho "Hello World"\napt-get update\napt-get install -y nginx',
+        project: {
+          id: 'proj_test123',
+          name: 'Test Project',
+          slug: 'test-project',
         },
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
       },
-      meta: {},
     },
     {
-      data: {
-        id: 'userdata_test456',
-        type: 'user_data',
-        attributes: {
-          description: 'Docker Setup Script',
-          content: '#!/bin/bash\ncurl -fsSL https://get.docker.com -o get-docker.sh\nsh get-docker.sh',
-          project: {
-            id: 'proj_test456',
-            name: 'Production Project',
-            slug: 'production-project',
-          },
-          created_at: '2024-01-02T00:00:00Z',
-          updated_at: '2024-01-02T00:00:00Z',
+      id: 'userdata_test456',
+      type: 'user_data',
+      attributes: {
+        description: 'Docker Setup Script',
+        content: '#!/bin/bash\ncurl -fsSL https://get.docker.com -o get-docker.sh\nsh get-docker.sh',
+        project: {
+          id: 'proj_test456',
+          name: 'Production Project',
+          slug: 'production-project',
         },
+        created_at: '2024-01-02T00:00:00Z',
+        updated_at: '2024-01-02T00:00:00Z',
       },
-      meta: {},
     },
   ],
   meta: {},

package/tests/integration/userdata.test.ts

@@ -33,9 +33,9 @@ describe('User Data - Core Operations', () => {
       // Assert
       expect(result.data).toBeDefined();
       expect(result.data.length).toBe(2);
-      expect(result.data[0].data?.id).toBe('userdata_test123');
-      expect(result.data[0].data?.type).toBe('user_data');
-      expect(result.data[0].data?.attributes?.description).toBe('Test User Data Script');
+      expect(result.data[0].id).toBe('userdata_test123');
+      expect(result.data[0].type).toBe('user_data');
+      expect(result.data[0].attributes?.description).toBe('Test User Data Script');
     });
 
     test('should handle empty user data list', async () => {
@@ -68,9 +68,9 @@ describe('User Data - Core Operations', () => {
 
       // Assert
       const userData = result.data[0];
-      expect(userData.data?.attributes?.content).toBeDefined();
-      expect(userData.data?.attributes?.content).toContain('#!/bin/bash');
-      expect(userData.data?.attributes?.content).toContain('apt-get update');
+      expect(userData.attributes?.content).toBeDefined();
+      expect(userData.attributes?.content).toContain('#!/bin/bash');
+      expect(userData.attributes?.content).toContain('apt-get update');
     });
 
     test('should include associated project', async () => {
@@ -85,10 +85,10 @@ describe('User Data - Core Operations', () => {
 
       // Assert
       const userData = result.data[0];
-      expect(userData.data?.attributes?.project).toBeDefined();
-      expect(userData.data?.attributes?.project?.id).toBe('proj_test123');
-      expect(userData.data?.attributes?.project?.name).toBe('Test Project');
-      expect(userData.data?.attributes?.project?.slug).toBe('test-project');
+      expect(userData.attributes?.project).toBeDefined();
+      expect(userData.attributes?.project?.id).toBe('proj_test123');
+      expect(userData.attributes?.project?.name).toBe('Test Project');
+      expect(userData.attributes?.project?.slug).toBe('test-project');
     });
 
     test('should include timestamps', async () => {
@@ -103,9 +103,9 @@ describe('User Data - Core Operations', () => {
 
       // Assert
       const userData = result.data[0];
-      expect(userData.data?.attributes?.createdAt).toBeDefined();
-      expect(userData.data?.attributes?.updatedAt).toBeDefined();
-      expect(userData.data?.attributes?.createdAt).toBe('2024-01-01T00:00:00Z');
+      expect(userData.attributes?.createdAt).toBeDefined();
+      expect(userData.attributes?.updatedAt).toBeDefined();
+      expect(userData.attributes?.createdAt).toBe('2024-01-01T00:00:00Z');
     });
   });
 
@@ -539,7 +539,7 @@ describe('User Data - Core Operations', () => {
 
       // Assert
       const bashScript = result.data[0];
-      expect(bashScript.data?.attributes?.content).toContain('#!/bin/bash');
+      expect(bashScript.attributes?.content).toContain('#!/bin/bash');
     });
 
     test('should handle multi-line scripts', async () => {
@@ -554,7 +554,7 @@ describe('User Data - Core Operations', () => {
 
       // Assert
       const script = result.data[0];
-      const content = script.data?.attributes?.content || '';
+      const content = script.attributes?.content || '';
       const lines = content.split('\n');
       expect(lines.length).toBeGreaterThan(1);
       expect(lines[0]).toBe('#!/bin/bash');
@@ -604,8 +604,8 @@ describe('User Data - Core Operations', () => {
       const { result } = await sdk.userData.list();
 
       // Assert
-      expect(result.data[0].data?.attributes?.project?.id).toBe('proj_test123');
-      expect(result.data[1].data?.attributes?.project?.id).toBe('proj_test456');
+      expect(result.data[0].attributes?.project?.id).toBe('proj_test123');
+      expect(result.data[1].attributes?.project?.id).toBe('proj_test456');
     });
 
     test('should include project slug', async () => {
@@ -620,7 +620,7 @@ describe('User Data - Core Operations', () => {
 
       // Assert
       const userData = result.data[0];
-      expect(userData.data?.attributes?.project?.slug).toBe('test-project');
+      expect(userData.attributes?.project?.slug).toBe('test-project');
     });
   });
 });