latitudesh-typescript-sdk 0.7.5 → 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/createserver.ts

@@ -5,7 +5,8 @@
 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 * as openEnums from "../../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -41,7 +42,7 @@ export const Plan2 = {
 /**
  * The plan slug to choose server from, defining the specs the server will have
  */
-export type Plan2 = ClosedEnum<typeof Plan2>;
+export type Plan2 = OpenEnum<typeof Plan2>;
 
 /**
  * The site slug to deploy the server
@@ -69,7 +70,7 @@ export const CreateServerSite2 = {
 /**
  * The site slug to deploy the server
  */
-export type CreateServerSite2 = ClosedEnum<typeof CreateServerSite2>;
+export type CreateServerSite2 = OpenEnum<typeof CreateServerSite2>;
 
 /**
  * The operating system slug for the new server
@@ -215,21 +216,24 @@ export const CreateServerType2$outboundSchema: z.ZodNativeEnum<
 > = CreateServerType2$inboundSchema;
 
 /** @internal */
-export const Plan2$inboundSchema: z.ZodNativeEnum<typeof Plan2> = z.nativeEnum(
-  Plan2,
-);
+export const Plan2$inboundSchema: z.ZodType<Plan2, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Plan2);
 /** @internal */
-export const Plan2$outboundSchema: z.ZodNativeEnum<typeof Plan2> =
-  Plan2$inboundSchema;
+export const Plan2$outboundSchema: z.ZodType<string, z.ZodTypeDef, Plan2> =
+  openEnums.outboundSchema(Plan2);
 
 /** @internal */
-export const CreateServerSite2$inboundSchema: z.ZodNativeEnum<
-  typeof CreateServerSite2
-> = z.nativeEnum(CreateServerSite2);
+export const CreateServerSite2$inboundSchema: z.ZodType<
+  CreateServerSite2,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CreateServerSite2);
 /** @internal */
-export const CreateServerSite2$outboundSchema: z.ZodNativeEnum<
-  typeof CreateServerSite2
-> = CreateServerSite2$inboundSchema;
+export const CreateServerSite2$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  CreateServerSite2
+> = openEnums.outboundSchema(CreateServerSite2);
 
 /** @internal */
 export const CreateServerOperatingSystem2$inboundSchema: z.ZodNativeEnum<

package/src/models/operations/createvirtualnetwork.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -16,7 +17,7 @@ export type CreateVirtualNetworkType2 = ClosedEnum<
 >;
 
 /**
- * Site ID or slug
+ * Site slug
  */
 export const CreateVirtualNetworkSite2 = {
   Ash: "ASH",
@@ -39,16 +40,16 @@ export const CreateVirtualNetworkSite2 = {
   Tyo2: "TYO2",
 } as const;
 /**
- * Site ID or slug
+ * Site slug
  */
-export type CreateVirtualNetworkSite2 = ClosedEnum<
+export type CreateVirtualNetworkSite2 = OpenEnum<
   typeof CreateVirtualNetworkSite2
 >;
 
 export type CreateVirtualNetworkAttributes2 = {
   description: string;
   /**
-   * Site ID or slug
+   * Site slug
    */
   site?: CreateVirtualNetworkSite2 | undefined;
   /**
@@ -76,13 +77,17 @@ export const CreateVirtualNetworkType2$outboundSchema: z.ZodNativeEnum<
 > = CreateVirtualNetworkType2$inboundSchema;
 
 /** @internal */
-export const CreateVirtualNetworkSite2$inboundSchema: z.ZodNativeEnum<
-  typeof CreateVirtualNetworkSite2
-> = z.nativeEnum(CreateVirtualNetworkSite2);
+export const CreateVirtualNetworkSite2$inboundSchema: z.ZodType<
+  CreateVirtualNetworkSite2,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CreateVirtualNetworkSite2);
 /** @internal */
-export const CreateVirtualNetworkSite2$outboundSchema: z.ZodNativeEnum<
-  typeof CreateVirtualNetworkSite2
-> = CreateVirtualNetworkSite2$inboundSchema;
+export const CreateVirtualNetworkSite2$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  CreateVirtualNetworkSite2
+> = openEnums.outboundSchema(CreateVirtualNetworkSite2);
 
 /** @internal */
 export const CreateVirtualNetworkAttributes2$inboundSchema: z.ZodType<

package/src/models/operations/getvpnsessions.ts

@@ -5,7 +5,8 @@
 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 * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
@@ -30,7 +31,7 @@ export const FilterLocation = {
   Tyo: "TYO",
   Tyo2: "TYO2",
 } as const;
-export type FilterLocation = ClosedEnum<typeof FilterLocation>;
+export type FilterLocation = OpenEnum<typeof FilterLocation>;
 
 export type GetVpnSessionsRequest = {
   filterLocation?: FilterLocation | undefined;
@@ -47,13 +48,17 @@ export type GetVpnSessionsResponse = {
 };
 
 /** @internal */
-export const FilterLocation$inboundSchema: z.ZodNativeEnum<
-  typeof FilterLocation
-> = z.nativeEnum(FilterLocation);
+export const FilterLocation$inboundSchema: z.ZodType<
+  FilterLocation,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(FilterLocation);
 /** @internal */
-export const FilterLocation$outboundSchema: z.ZodNativeEnum<
-  typeof FilterLocation
-> = FilterLocation$inboundSchema;
+export const FilterLocation$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  FilterLocation
+> = openEnums.outboundSchema(FilterLocation);
 
 /** @internal */
 export const GetVpnSessionsRequest$inboundSchema: z.ZodType<