latitudesh-typescript-sdk 0.8.0 → 0.8.1

package/src/models/billingusage.ts

@@ -9,6 +9,8 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 
+export type BillingUsageMeta = {};
+
 /**
  * The project in which the returned usage belongs to
  */
@@ -57,6 +59,7 @@ export const BillingUsageUnit = {
   Quantity: "quantity",
   Hour: "hour",
   Minute: "minute",
+  Gb: "GB",
 } as const;
 export type BillingUsageUnit = ClosedEnum<typeof BillingUsageUnit>;
 
@@ -66,13 +69,28 @@ export const UsageType = {
 } as const;
 export type UsageType = ClosedEnum<typeof UsageType>;
 
-export type Metadata = {
-  id?: string | null | undefined;
-  hostname?: string | null | undefined;
-  plan?: string | null | undefined;
+export type BillingUsageServer = {
+  id?: string | undefined;
+  hostname?: string | undefined;
+  plan?: string | undefined;
   tags?: Array<string> | undefined;
 };
 
+export type Bucket = {
+  id?: string | undefined;
+  name?: string | undefined;
+  location?: string | null | undefined;
+};
+
+export type Metadata = {
+  servers?: Array<BillingUsageServer> | undefined;
+  bucket?: Bucket | undefined;
+  /**
+   * For products priced per divided unit (e.g. $0.01 per 1000 API calls), the divisor applied to the quantity before pricing. Omitted for products that are not priced by divided units.
+   */
+  billingUnitDivisor?: number | null | undefined;
+};
+
 export type Product = {
   id?: string | undefined;
   resource?: string | undefined;
@@ -85,12 +103,20 @@ export type Product = {
   start?: Date | undefined;
   end?: Date | null | undefined;
   unit?: BillingUsageUnit | undefined;
+  /**
+   * The unit amount of the product in cents
+   */
+  unitAmount?: number | undefined;
   /**
    * The unit price of the product in cents
    */
   unitPrice?: number | undefined;
   usageType?: UsageType | undefined;
   quantity?: number | undefined;
+  /**
+   * The total usage amount of the product in cents
+   */
+  amount?: number | undefined;
   /**
    * The total usage price of the product in cents
    */
@@ -111,6 +137,10 @@ export type BillingUsageAttributes = {
    * The available credit balance in cents
    */
   availableCreditBalance?: number | undefined;
+  /**
+   * The total usage amount in cents
+   */
+  amount?: number | undefined;
   /**
    * The total usage price in cents
    */
@@ -124,13 +154,48 @@ export type BillingUsageAttributes = {
 
 export type BillingUsageData = {
   id?: string | undefined;
+  type?: string | undefined;
   attributes?: BillingUsageAttributes | undefined;
 };
 
 export type BillingUsage = {
+  meta?: BillingUsageMeta | undefined;
   data?: BillingUsageData | undefined;
 };
 
+/** @internal */
+export const BillingUsageMeta$inboundSchema: z.ZodType<
+  BillingUsageMeta,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type BillingUsageMeta$Outbound = {};
+
+/** @internal */
+export const BillingUsageMeta$outboundSchema: z.ZodType<
+  BillingUsageMeta$Outbound,
+  z.ZodTypeDef,
+  BillingUsageMeta
+> = z.object({});
+
+export function billingUsageMetaToJSON(
+  billingUsageMeta: BillingUsageMeta,
+): string {
+  return JSON.stringify(
+    BillingUsageMeta$outboundSchema.parse(billingUsageMeta),
+  );
+}
+export function billingUsageMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<BillingUsageMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BillingUsageMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BillingUsageMeta' from JSON`,
+  );
+}
+
 /** @internal */
 export const BillingUsageProject$inboundSchema: z.ZodType<
   BillingUsageProject,
@@ -279,23 +344,111 @@ export const UsageType$inboundSchema: z.ZodNativeEnum<typeof UsageType> = z
 export const UsageType$outboundSchema: z.ZodNativeEnum<typeof UsageType> =
   UsageType$inboundSchema;
 
+/** @internal */
+export const BillingUsageServer$inboundSchema: z.ZodType<
+  BillingUsageServer,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  hostname: z.string().optional(),
+  plan: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+});
+/** @internal */
+export type BillingUsageServer$Outbound = {
+  id?: string | undefined;
+  hostname?: string | undefined;
+  plan?: string | undefined;
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export const BillingUsageServer$outboundSchema: z.ZodType<
+  BillingUsageServer$Outbound,
+  z.ZodTypeDef,
+  BillingUsageServer
+> = z.object({
+  id: z.string().optional(),
+  hostname: z.string().optional(),
+  plan: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+export function billingUsageServerToJSON(
+  billingUsageServer: BillingUsageServer,
+): string {
+  return JSON.stringify(
+    BillingUsageServer$outboundSchema.parse(billingUsageServer),
+  );
+}
+export function billingUsageServerFromJSON(
+  jsonString: string,
+): SafeParseResult<BillingUsageServer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BillingUsageServer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BillingUsageServer' from JSON`,
+  );
+}
+
+/** @internal */
+export const Bucket$inboundSchema: z.ZodType<Bucket, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    location: z.nullable(z.string()).optional(),
+  });
+/** @internal */
+export type Bucket$Outbound = {
+  id?: string | undefined;
+  name?: string | undefined;
+  location?: string | null | undefined;
+};
+
+/** @internal */
+export const Bucket$outboundSchema: z.ZodType<
+  Bucket$Outbound,
+  z.ZodTypeDef,
+  Bucket
+> = z.object({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  location: z.nullable(z.string()).optional(),
+});
+
+export function bucketToJSON(bucket: Bucket): string {
+  return JSON.stringify(Bucket$outboundSchema.parse(bucket));
+}
+export function bucketFromJSON(
+  jsonString: string,
+): SafeParseResult<Bucket, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Bucket$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Bucket' from JSON`,
+  );
+}
+
 /** @internal */
 export const Metadata$inboundSchema: z.ZodType<
   Metadata,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.nullable(z.string()).optional(),
-  hostname: z.nullable(z.string()).optional(),
-  plan: z.nullable(z.string()).optional(),
-  tags: z.array(z.string()).optional(),
+  servers: z.array(z.lazy(() => BillingUsageServer$inboundSchema)).optional(),
+  bucket: z.lazy(() => Bucket$inboundSchema).optional(),
+  billing_unit_divisor: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "billing_unit_divisor": "billingUnitDivisor",
+  });
 });
 /** @internal */
 export type Metadata$Outbound = {
-  id?: string | null | undefined;
-  hostname?: string | null | undefined;
-  plan?: string | null | undefined;
-  tags?: Array<string> | undefined;
+  servers?: Array<BillingUsageServer$Outbound> | undefined;
+  bucket?: Bucket$Outbound | undefined;
+  billing_unit_divisor?: number | null | undefined;
 };
 
 /** @internal */
@@ -304,10 +457,13 @@ export const Metadata$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Metadata
 > = z.object({
-  id: z.nullable(z.string()).optional(),
-  hostname: z.nullable(z.string()).optional(),
-  plan: z.nullable(z.string()).optional(),
-  tags: z.array(z.string()).optional(),
+  servers: z.array(z.lazy(() => BillingUsageServer$outboundSchema)).optional(),
+  bucket: z.lazy(() => Bucket$outboundSchema).optional(),
+  billingUnitDivisor: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    billingUnitDivisor: "billing_unit_divisor",
+  });
 });
 
 export function metadataToJSON(metadata: Metadata): string {
@@ -340,14 +496,17 @@ export const Product$inboundSchema: z.ZodType<Product, z.ZodTypeDef, unknown> =
       z.string().datetime({ offset: true }).transform(v => new Date(v)),
     ).optional(),
     unit: BillingUsageUnit$inboundSchema.optional(),
+    unit_amount: z.number().optional(),
     unit_price: z.number().optional(),
     usage_type: UsageType$inboundSchema.optional(),
     quantity: z.number().optional(),
+    amount: z.number().optional(),
     price: z.number().optional(),
     metadata: z.lazy(() => Metadata$inboundSchema).optional(),
   }).transform((v) => {
     return remap$(v, {
       "amount_without_discount": "amountWithoutDiscount",
+      "unit_amount": "unitAmount",
       "unit_price": "unitPrice",
       "usage_type": "usageType",
     });
@@ -365,9 +524,11 @@ export type Product$Outbound = {
   start?: string | undefined;
   end?: string | null | undefined;
   unit?: string | undefined;
+  unit_amount?: number | undefined;
   unit_price?: number | undefined;
   usage_type?: string | undefined;
   quantity?: number | undefined;
+  amount?: number | undefined;
   price?: number | undefined;
   metadata?: Metadata$Outbound | undefined;
 };
@@ -389,14 +550,17 @@ export const Product$outboundSchema: z.ZodType<
   start: z.date().transform(v => v.toISOString()).optional(),
   end: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   unit: BillingUsageUnit$outboundSchema.optional(),
+  unitAmount: z.number().optional(),
   unitPrice: z.number().optional(),
   usageType: UsageType$outboundSchema.optional(),
   quantity: z.number().optional(),
+  amount: z.number().optional(),
   price: z.number().optional(),
   metadata: z.lazy(() => Metadata$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     amountWithoutDiscount: "amount_without_discount",
+    unitAmount: "unit_amount",
     unitPrice: "unit_price",
     usageType: "usage_type",
   });
@@ -424,6 +588,7 @@ export const BillingUsageAttributes$inboundSchema: z.ZodType<
   project: z.lazy(() => BillingUsageProject$inboundSchema).optional(),
   period: z.lazy(() => Period$inboundSchema).optional(),
   available_credit_balance: z.number().int().optional(),
+  amount: z.number().optional(),
   price: z.number().optional(),
   threshold: z.nullable(z.number()).optional(),
   products: z.array(z.lazy(() => Product$inboundSchema)).optional(),
@@ -437,6 +602,7 @@ export type BillingUsageAttributes$Outbound = {
   project?: BillingUsageProject$Outbound | undefined;
   period?: Period$Outbound | undefined;
   available_credit_balance?: number | undefined;
+  amount?: number | undefined;
   price?: number | undefined;
   threshold?: number | null | undefined;
   products?: Array<Product$Outbound> | undefined;
@@ -451,6 +617,7 @@ export const BillingUsageAttributes$outboundSchema: z.ZodType<
   project: z.lazy(() => BillingUsageProject$outboundSchema).optional(),
   period: z.lazy(() => Period$outboundSchema).optional(),
   availableCreditBalance: z.number().int().optional(),
+  amount: z.number().optional(),
   price: z.number().optional(),
   threshold: z.nullable(z.number()).optional(),
   products: z.array(z.lazy(() => Product$outboundSchema)).optional(),
@@ -484,11 +651,13 @@ export const BillingUsageData$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string().optional(),
+  type: z.string().optional(),
   attributes: z.lazy(() => BillingUsageAttributes$inboundSchema).optional(),
 });
 /** @internal */
 export type BillingUsageData$Outbound = {
   id?: string | undefined;
+  type?: string | undefined;
   attributes?: BillingUsageAttributes$Outbound | undefined;
 };
 
@@ -499,6 +668,7 @@ export const BillingUsageData$outboundSchema: z.ZodType<
   BillingUsageData
 > = z.object({
   id: z.string().optional(),
+  type: z.string().optional(),
   attributes: z.lazy(() => BillingUsageAttributes$outboundSchema).optional(),
 });
 
@@ -525,10 +695,12 @@ export const BillingUsage$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  meta: z.lazy(() => BillingUsageMeta$inboundSchema).optional(),
   data: z.lazy(() => BillingUsageData$inboundSchema).optional(),
 });
 /** @internal */
 export type BillingUsage$Outbound = {
+  meta?: BillingUsageMeta$Outbound | undefined;
   data?: BillingUsageData$Outbound | undefined;
 };
 
@@ -538,6 +710,7 @@ export const BillingUsage$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   BillingUsage
 > = z.object({
+  meta: z.lazy(() => BillingUsageMeta$outboundSchema).optional(),
   data: z.lazy(() => BillingUsageData$outboundSchema).optional(),
 });
 

package/src/models/eventdata.ts

@@ -15,20 +15,20 @@ export const EventDataType = {
 export type EventDataType = ClosedEnum<typeof EventDataType>;
 
 export type Author = {
-  id?: string | undefined;
-  name?: string | undefined;
-  email?: string | undefined;
+  id?: string | null | undefined;
+  name?: string | null | undefined;
+  email?: string | null | undefined;
 };
 
 export type EventDataProject = {
-  id?: string | undefined;
-  name?: string | undefined;
-  slug?: string | undefined;
+  id?: string | null | undefined;
+  name?: string | null | undefined;
+  slug?: string | null | undefined;
 };
 
 export type EventDataTeam = {
-  id?: string | undefined;
-  name?: string | undefined;
+  id?: string | null | undefined;
+  name?: string | null | undefined;
 };
 
 export type Target = {
@@ -72,15 +72,15 @@ export const EventDataType$outboundSchema: z.ZodNativeEnum<
 /** @internal */
 export const Author$inboundSchema: z.ZodType<Author, z.ZodTypeDef, unknown> = z
   .object({
-    id: z.string().optional(),
-    name: z.string().optional(),
-    email: z.string().optional(),
+    id: z.nullable(z.string()).optional(),
+    name: z.nullable(z.string()).optional(),
+    email: z.nullable(z.string()).optional(),
   });
 /** @internal */
 export type Author$Outbound = {
-  id?: string | undefined;
-  name?: string | undefined;
-  email?: string | undefined;
+  id?: string | null | undefined;
+  name?: string | null | undefined;
+  email?: string | null | undefined;
 };
 
 /** @internal */
@@ -89,9 +89,9 @@ export const Author$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Author
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  email: z.string().optional(),
+  id: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
+  email: z.nullable(z.string()).optional(),
 });
 
 export function authorToJSON(author: Author): string {
@@ -113,15 +113,15 @@ export const EventDataProject$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  slug: z.string().optional(),
+  id: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
+  slug: z.nullable(z.string()).optional(),
 });
 /** @internal */
 export type EventDataProject$Outbound = {
-  id?: string | undefined;
-  name?: string | undefined;
-  slug?: string | undefined;
+  id?: string | null | undefined;
+  name?: string | null | undefined;
+  slug?: string | null | undefined;
 };
 
 /** @internal */
@@ -130,9 +130,9 @@ export const EventDataProject$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EventDataProject
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
-  slug: z.string().optional(),
+  id: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
+  slug: z.nullable(z.string()).optional(),
 });
 
 export function eventDataProjectToJSON(
@@ -158,13 +158,13 @@ export const EventDataTeam$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
+  id: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
 });
 /** @internal */
 export type EventDataTeam$Outbound = {
-  id?: string | undefined;
-  name?: string | undefined;
+  id?: string | null | undefined;
+  name?: string | null | undefined;
 };
 
 /** @internal */
@@ -173,8 +173,8 @@ export const EventDataTeam$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   EventDataTeam
 > = z.object({
-  id: z.string().optional(),
-  name: z.string().optional(),
+  id: z.nullable(z.string()).optional(),
+  name: z.nullable(z.string()).optional(),
 });
 
 export function eventDataTeamToJSON(eventDataTeam: EventDataTeam): string {

package/src/models/operations/indexvirtualmachine.ts

@@ -7,6 +7,7 @@ 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 * as models from "../index.js";
 
 export type IndexVirtualMachineRequest = {
   /**
@@ -25,6 +26,22 @@ export type IndexVirtualMachineRequest = {
    * Comma-separated sort fields. Prefix a field with `-` for descending order. Supported fields: created_at, name, hostname, status. Example: `sort=status,-created_at` sorts by status ascending, then by creation date descending.
    */
   sort?: string | undefined;
+  /**
+   * Number of items to return per page
+   */
+  pageSize?: number | undefined;
+  /**
+   * Page number to return (starts at 1)
+   */
+  pageNumber?: number | undefined;
+  /**
+   * Request aggregate stats in the response `meta`. Use `count` to get the total number of records, returned as `meta.stats.total.count`.
+   */
+  statsTotal?: string | undefined;
+};
+
+export type IndexVirtualMachineResponse = {
+  result: models.VirtualMachines;
 };
 
 /** @internal */
@@ -37,11 +54,17 @@ export const IndexVirtualMachineRequest$inboundSchema: z.ZodType<
   "filter[tags]": z.string().optional(),
   "extra_fields[virtual_machines]": z.string().optional(),
   sort: z.string().optional(),
+  "page[size]": z.number().int().default(20),
+  "page[number]": z.number().int().default(1),
+  "stats[total]": z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     "filter[project]": "filterProject",
     "filter[tags]": "filterTags",
     "extra_fields[virtual_machines]": "extraFieldsVirtualMachines",
+    "page[size]": "pageSize",
+    "page[number]": "pageNumber",
+    "stats[total]": "statsTotal",
   });
 });
 /** @internal */
@@ -50,6 +73,9 @@ export type IndexVirtualMachineRequest$Outbound = {
   "filter[tags]"?: string | undefined;
   "extra_fields[virtual_machines]"?: string | undefined;
   sort?: string | undefined;
+  "page[size]": number;
+  "page[number]": number;
+  "stats[total]"?: string | undefined;
 };
 
 /** @internal */
@@ -62,11 +88,17 @@ export const IndexVirtualMachineRequest$outboundSchema: z.ZodType<
   filterTags: z.string().optional(),
   extraFieldsVirtualMachines: z.string().optional(),
   sort: z.string().optional(),
+  pageSize: z.number().int().default(20),
+  pageNumber: z.number().int().default(1),
+  statsTotal: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     filterProject: "filter[project]",
     filterTags: "filter[tags]",
     extraFieldsVirtualMachines: "extra_fields[virtual_machines]",
+    pageSize: "page[size]",
+    pageNumber: "page[number]",
+    statsTotal: "stats[total]",
   });
 });
 
@@ -86,3 +118,52 @@ export function indexVirtualMachineRequestFromJSON(
     `Failed to parse 'IndexVirtualMachineRequest' from JSON`,
   );
 }
+
+/** @internal */
+export const IndexVirtualMachineResponse$inboundSchema: z.ZodType<
+  IndexVirtualMachineResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Result: models.VirtualMachines$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Result": "result",
+  });
+});
+/** @internal */
+export type IndexVirtualMachineResponse$Outbound = {
+  Result: models.VirtualMachines$Outbound;
+};
+
+/** @internal */
+export const IndexVirtualMachineResponse$outboundSchema: z.ZodType<
+  IndexVirtualMachineResponse$Outbound,
+  z.ZodTypeDef,
+  IndexVirtualMachineResponse
+> = z.object({
+  result: models.VirtualMachines$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    result: "Result",
+  });
+});
+
+export function indexVirtualMachineResponseToJSON(
+  indexVirtualMachineResponse: IndexVirtualMachineResponse,
+): string {
+  return JSON.stringify(
+    IndexVirtualMachineResponse$outboundSchema.parse(
+      indexVirtualMachineResponse,
+    ),
+  );
+}
+export function indexVirtualMachineResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<IndexVirtualMachineResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => IndexVirtualMachineResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'IndexVirtualMachineResponse' from JSON`,
+  );
+}