latitudesh-typescript-sdk 0.2.1 → 0.2.2

package/src/models/containerplandata.ts

@@ -0,0 +1,663 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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";
+
+export const ContainerPlanDataType = {
+  ContainerPlan: "container_plan",
+} as const;
+export type ContainerPlanDataType = ClosedEnum<typeof ContainerPlanDataType>;
+
+export type ContainerPlanDataCpu = {
+  cores?: number | undefined;
+  count?: number | undefined;
+};
+
+export type ContainerPlanDataMemory = {
+  total?: number | undefined;
+};
+
+export type EphemeralStorage = {
+  size?: number | undefined;
+};
+
+export type ContainerPlanDataGpu = {
+  count?: number | undefined;
+  type?: string | undefined;
+};
+
+export type ContainerPlanDataSpecs = {
+  cpu?: ContainerPlanDataCpu | undefined;
+  memory?: ContainerPlanDataMemory | undefined;
+  ephemeralStorage?: EphemeralStorage | undefined;
+  gpu?: ContainerPlanDataGpu | undefined;
+};
+
+export type ContainerPlanDataLocations = {
+  available?: Array<string> | undefined;
+  inStock?: Array<string> | undefined;
+};
+
+export const ContainerPlanDataStockLevel = {
+  Unavailable: "unavailable",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+} as const;
+export type ContainerPlanDataStockLevel = ClosedEnum<
+  typeof ContainerPlanDataStockLevel
+>;
+
+export type ContainerPlanDataUSD = {
+  minute?: number | undefined;
+  hour?: number | undefined;
+};
+
+export type ContainerPlanDataBRL = {
+  minute?: number | undefined;
+  hour?: number | undefined;
+};
+
+export type ContainerPlanDataPricing = {
+  usd?: ContainerPlanDataUSD | undefined;
+  brl?: ContainerPlanDataBRL | undefined;
+};
+
+export type ContainerPlanDataRegion = {
+  name?: string | undefined;
+  locations?: ContainerPlanDataLocations | undefined;
+  stockLevel?: ContainerPlanDataStockLevel | undefined;
+  pricing?: ContainerPlanDataPricing | undefined;
+};
+
+export type ContainerPlanDataAttributes = {
+  slug?: string | undefined;
+  specs?: ContainerPlanDataSpecs | undefined;
+  regions?: Array<ContainerPlanDataRegion> | undefined;
+};
+
+export type ContainerPlanData = {
+  id?: string | undefined;
+  type?: ContainerPlanDataType | undefined;
+  attributes?: ContainerPlanDataAttributes | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataType$inboundSchema: z.ZodNativeEnum<
+  typeof ContainerPlanDataType
+> = z.nativeEnum(ContainerPlanDataType);
+/** @internal */
+export const ContainerPlanDataType$outboundSchema: z.ZodNativeEnum<
+  typeof ContainerPlanDataType
+> = ContainerPlanDataType$inboundSchema;
+
+/** @internal */
+export const ContainerPlanDataCpu$inboundSchema: z.ZodType<
+  ContainerPlanDataCpu,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cores: z.number().optional(),
+  count: z.number().optional(),
+});
+/** @internal */
+export type ContainerPlanDataCpu$Outbound = {
+  cores?: number | undefined;
+  count?: number | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataCpu$outboundSchema: z.ZodType<
+  ContainerPlanDataCpu$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataCpu
+> = z.object({
+  cores: z.number().optional(),
+  count: z.number().optional(),
+});
+
+export function containerPlanDataCpuToJSON(
+  containerPlanDataCpu: ContainerPlanDataCpu,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataCpu$outboundSchema.parse(containerPlanDataCpu),
+  );
+}
+export function containerPlanDataCpuFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataCpu, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataCpu$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataCpu' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataMemory$inboundSchema: z.ZodType<
+  ContainerPlanDataMemory,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  total: z.number().optional(),
+});
+/** @internal */
+export type ContainerPlanDataMemory$Outbound = {
+  total?: number | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataMemory$outboundSchema: z.ZodType<
+  ContainerPlanDataMemory$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataMemory
+> = z.object({
+  total: z.number().optional(),
+});
+
+export function containerPlanDataMemoryToJSON(
+  containerPlanDataMemory: ContainerPlanDataMemory,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataMemory$outboundSchema.parse(containerPlanDataMemory),
+  );
+}
+export function containerPlanDataMemoryFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataMemory, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataMemory$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataMemory' from JSON`,
+  );
+}
+
+/** @internal */
+export const EphemeralStorage$inboundSchema: z.ZodType<
+  EphemeralStorage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  size: z.number().optional(),
+});
+/** @internal */
+export type EphemeralStorage$Outbound = {
+  size?: number | undefined;
+};
+
+/** @internal */
+export const EphemeralStorage$outboundSchema: z.ZodType<
+  EphemeralStorage$Outbound,
+  z.ZodTypeDef,
+  EphemeralStorage
+> = z.object({
+  size: z.number().optional(),
+});
+
+export function ephemeralStorageToJSON(
+  ephemeralStorage: EphemeralStorage,
+): string {
+  return JSON.stringify(
+    EphemeralStorage$outboundSchema.parse(ephemeralStorage),
+  );
+}
+export function ephemeralStorageFromJSON(
+  jsonString: string,
+): SafeParseResult<EphemeralStorage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EphemeralStorage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EphemeralStorage' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataGpu$inboundSchema: z.ZodType<
+  ContainerPlanDataGpu,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().optional(),
+  type: z.string().optional(),
+});
+/** @internal */
+export type ContainerPlanDataGpu$Outbound = {
+  count?: number | undefined;
+  type?: string | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataGpu$outboundSchema: z.ZodType<
+  ContainerPlanDataGpu$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataGpu
+> = z.object({
+  count: z.number().optional(),
+  type: z.string().optional(),
+});
+
+export function containerPlanDataGpuToJSON(
+  containerPlanDataGpu: ContainerPlanDataGpu,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataGpu$outboundSchema.parse(containerPlanDataGpu),
+  );
+}
+export function containerPlanDataGpuFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataGpu, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataGpu$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataGpu' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataSpecs$inboundSchema: z.ZodType<
+  ContainerPlanDataSpecs,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  cpu: z.lazy(() => ContainerPlanDataCpu$inboundSchema).optional(),
+  memory: z.lazy(() => ContainerPlanDataMemory$inboundSchema).optional(),
+  ephemeral_storage: z.lazy(() => EphemeralStorage$inboundSchema).optional(),
+  gpu: z.lazy(() => ContainerPlanDataGpu$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "ephemeral_storage": "ephemeralStorage",
+  });
+});
+/** @internal */
+export type ContainerPlanDataSpecs$Outbound = {
+  cpu?: ContainerPlanDataCpu$Outbound | undefined;
+  memory?: ContainerPlanDataMemory$Outbound | undefined;
+  ephemeral_storage?: EphemeralStorage$Outbound | undefined;
+  gpu?: ContainerPlanDataGpu$Outbound | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataSpecs$outboundSchema: z.ZodType<
+  ContainerPlanDataSpecs$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataSpecs
+> = z.object({
+  cpu: z.lazy(() => ContainerPlanDataCpu$outboundSchema).optional(),
+  memory: z.lazy(() => ContainerPlanDataMemory$outboundSchema).optional(),
+  ephemeralStorage: z.lazy(() => EphemeralStorage$outboundSchema).optional(),
+  gpu: z.lazy(() => ContainerPlanDataGpu$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    ephemeralStorage: "ephemeral_storage",
+  });
+});
+
+export function containerPlanDataSpecsToJSON(
+  containerPlanDataSpecs: ContainerPlanDataSpecs,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataSpecs$outboundSchema.parse(containerPlanDataSpecs),
+  );
+}
+export function containerPlanDataSpecsFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataSpecs, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataSpecs$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataSpecs' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataLocations$inboundSchema: z.ZodType<
+  ContainerPlanDataLocations,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  available: z.array(z.string()).optional(),
+  in_stock: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "in_stock": "inStock",
+  });
+});
+/** @internal */
+export type ContainerPlanDataLocations$Outbound = {
+  available?: Array<string> | undefined;
+  in_stock?: Array<string> | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataLocations$outboundSchema: z.ZodType<
+  ContainerPlanDataLocations$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataLocations
+> = z.object({
+  available: z.array(z.string()).optional(),
+  inStock: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    inStock: "in_stock",
+  });
+});
+
+export function containerPlanDataLocationsToJSON(
+  containerPlanDataLocations: ContainerPlanDataLocations,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataLocations$outboundSchema.parse(containerPlanDataLocations),
+  );
+}
+export function containerPlanDataLocationsFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataLocations, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataLocations$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataLocations' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataStockLevel$inboundSchema: z.ZodNativeEnum<
+  typeof ContainerPlanDataStockLevel
+> = z.nativeEnum(ContainerPlanDataStockLevel);
+/** @internal */
+export const ContainerPlanDataStockLevel$outboundSchema: z.ZodNativeEnum<
+  typeof ContainerPlanDataStockLevel
+> = ContainerPlanDataStockLevel$inboundSchema;
+
+/** @internal */
+export const ContainerPlanDataUSD$inboundSchema: z.ZodType<
+  ContainerPlanDataUSD,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  minute: z.number().optional(),
+  hour: z.number().optional(),
+});
+/** @internal */
+export type ContainerPlanDataUSD$Outbound = {
+  minute?: number | undefined;
+  hour?: number | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataUSD$outboundSchema: z.ZodType<
+  ContainerPlanDataUSD$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataUSD
+> = z.object({
+  minute: z.number().optional(),
+  hour: z.number().optional(),
+});
+
+export function containerPlanDataUSDToJSON(
+  containerPlanDataUSD: ContainerPlanDataUSD,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataUSD$outboundSchema.parse(containerPlanDataUSD),
+  );
+}
+export function containerPlanDataUSDFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataUSD, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataUSD$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataUSD' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataBRL$inboundSchema: z.ZodType<
+  ContainerPlanDataBRL,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  minute: z.number().optional(),
+  hour: z.number().optional(),
+});
+/** @internal */
+export type ContainerPlanDataBRL$Outbound = {
+  minute?: number | undefined;
+  hour?: number | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataBRL$outboundSchema: z.ZodType<
+  ContainerPlanDataBRL$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataBRL
+> = z.object({
+  minute: z.number().optional(),
+  hour: z.number().optional(),
+});
+
+export function containerPlanDataBRLToJSON(
+  containerPlanDataBRL: ContainerPlanDataBRL,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataBRL$outboundSchema.parse(containerPlanDataBRL),
+  );
+}
+export function containerPlanDataBRLFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataBRL, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataBRL$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataBRL' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataPricing$inboundSchema: z.ZodType<
+  ContainerPlanDataPricing,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  USD: z.lazy(() => ContainerPlanDataUSD$inboundSchema).optional(),
+  BRL: z.lazy(() => ContainerPlanDataBRL$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "USD": "usd",
+    "BRL": "brl",
+  });
+});
+/** @internal */
+export type ContainerPlanDataPricing$Outbound = {
+  USD?: ContainerPlanDataUSD$Outbound | undefined;
+  BRL?: ContainerPlanDataBRL$Outbound | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataPricing$outboundSchema: z.ZodType<
+  ContainerPlanDataPricing$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataPricing
+> = z.object({
+  usd: z.lazy(() => ContainerPlanDataUSD$outboundSchema).optional(),
+  brl: z.lazy(() => ContainerPlanDataBRL$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    usd: "USD",
+    brl: "BRL",
+  });
+});
+
+export function containerPlanDataPricingToJSON(
+  containerPlanDataPricing: ContainerPlanDataPricing,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataPricing$outboundSchema.parse(containerPlanDataPricing),
+  );
+}
+export function containerPlanDataPricingFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataPricing, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataPricing$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataPricing' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataRegion$inboundSchema: z.ZodType<
+  ContainerPlanDataRegion,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string().optional(),
+  locations: z.lazy(() => ContainerPlanDataLocations$inboundSchema).optional(),
+  stock_level: ContainerPlanDataStockLevel$inboundSchema.optional(),
+  pricing: z.lazy(() => ContainerPlanDataPricing$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "stock_level": "stockLevel",
+  });
+});
+/** @internal */
+export type ContainerPlanDataRegion$Outbound = {
+  name?: string | undefined;
+  locations?: ContainerPlanDataLocations$Outbound | undefined;
+  stock_level?: string | undefined;
+  pricing?: ContainerPlanDataPricing$Outbound | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataRegion$outboundSchema: z.ZodType<
+  ContainerPlanDataRegion$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataRegion
+> = z.object({
+  name: z.string().optional(),
+  locations: z.lazy(() => ContainerPlanDataLocations$outboundSchema).optional(),
+  stockLevel: ContainerPlanDataStockLevel$outboundSchema.optional(),
+  pricing: z.lazy(() => ContainerPlanDataPricing$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    stockLevel: "stock_level",
+  });
+});
+
+export function containerPlanDataRegionToJSON(
+  containerPlanDataRegion: ContainerPlanDataRegion,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataRegion$outboundSchema.parse(containerPlanDataRegion),
+  );
+}
+export function containerPlanDataRegionFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataRegion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataRegion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataRegion' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanDataAttributes$inboundSchema: z.ZodType<
+  ContainerPlanDataAttributes,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  slug: z.string().optional(),
+  specs: z.lazy(() => ContainerPlanDataSpecs$inboundSchema).optional(),
+  regions: z.array(z.lazy(() => ContainerPlanDataRegion$inboundSchema))
+    .optional(),
+});
+/** @internal */
+export type ContainerPlanDataAttributes$Outbound = {
+  slug?: string | undefined;
+  specs?: ContainerPlanDataSpecs$Outbound | undefined;
+  regions?: Array<ContainerPlanDataRegion$Outbound> | undefined;
+};
+
+/** @internal */
+export const ContainerPlanDataAttributes$outboundSchema: z.ZodType<
+  ContainerPlanDataAttributes$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanDataAttributes
+> = z.object({
+  slug: z.string().optional(),
+  specs: z.lazy(() => ContainerPlanDataSpecs$outboundSchema).optional(),
+  regions: z.array(z.lazy(() => ContainerPlanDataRegion$outboundSchema))
+    .optional(),
+});
+
+export function containerPlanDataAttributesToJSON(
+  containerPlanDataAttributes: ContainerPlanDataAttributes,
+): string {
+  return JSON.stringify(
+    ContainerPlanDataAttributes$outboundSchema.parse(
+      containerPlanDataAttributes,
+    ),
+  );
+}
+export function containerPlanDataAttributesFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanDataAttributes, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanDataAttributes$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanDataAttributes' from JSON`,
+  );
+}
+
+/** @internal */
+export const ContainerPlanData$inboundSchema: z.ZodType<
+  ContainerPlanData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  type: ContainerPlanDataType$inboundSchema.optional(),
+  attributes: z.lazy(() => ContainerPlanDataAttributes$inboundSchema)
+    .optional(),
+});
+/** @internal */
+export type ContainerPlanData$Outbound = {
+  id?: string | undefined;
+  type?: string | undefined;
+  attributes?: ContainerPlanDataAttributes$Outbound | undefined;
+};
+
+/** @internal */
+export const ContainerPlanData$outboundSchema: z.ZodType<
+  ContainerPlanData$Outbound,
+  z.ZodTypeDef,
+  ContainerPlanData
+> = z.object({
+  id: z.string().optional(),
+  type: ContainerPlanDataType$outboundSchema.optional(),
+  attributes: z.lazy(() => ContainerPlanDataAttributes$outboundSchema)
+    .optional(),
+});
+
+export function containerPlanDataToJSON(
+  containerPlanData: ContainerPlanData,
+): string {
+  return JSON.stringify(
+    ContainerPlanData$outboundSchema.parse(containerPlanData),
+  );
+}
+export function containerPlanDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ContainerPlanData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ContainerPlanData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ContainerPlanData' from JSON`,
+  );
+}

package/src/models/createapikey.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";
@@ -18,6 +19,14 @@ export type CreateApiKeyAttributes = {
    * Name of the API Key
    */
   name?: string | undefined;
+  /**
+   * Whether the API Key is read-only. Read-only keys can only perform GET requests.
+   */
+  readOnly?: boolean | undefined;
+  /**
+   * List of allowed IP addresses or CIDR ranges (e.g., "192.168.1.100", "10.0.0.0/24")
+   */
+  allowedIps?: Array<string> | undefined;
 };
 
 export type CreateApiKeyData = {
@@ -45,10 +54,19 @@ export const CreateApiKeyAttributes$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   name: z.string().default("Name of the API Key"),
+  read_only: z.boolean().optional(),
+  allowed_ips: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "read_only": "readOnly",
+    "allowed_ips": "allowedIps",
+  });
 });
 /** @internal */
 export type CreateApiKeyAttributes$Outbound = {
   name: string;
+  read_only?: boolean | undefined;
+  allowed_ips?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -58,6 +76,13 @@ export const CreateApiKeyAttributes$outboundSchema: z.ZodType<
   CreateApiKeyAttributes
 > = z.object({
   name: z.string().default("Name of the API Key"),
+  readOnly: z.boolean().optional(),
+  allowedIps: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    readOnly: "read_only",
+    allowedIps: "allowed_ips",
+  });
 });
 
 export function createApiKeyAttributesToJSON(