/*
 * 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 { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";

export type ComputeOfferCapabilities = {
  customImage: boolean;
  httpPorts: boolean;
  managedService: boolean;
  multiNode: boolean;
  persistentVolume: boolean;
  scaleToZero: boolean;
  sharedVolume: boolean;
  ssh: boolean;
  tcpPorts: boolean;
};

export type Compute = {
  accelerator: string;
  ephemeralDiskGb: number;
  gpuCount: number;
  gpuMemoryGb: number;
  instanceCount: number;
  interconnect?: string | undefined;
  memoryGb: number;
  vcpus: number;
};

export type Region = {
  country?: string | undefined;
  name: string;
};

export type ComputeOffer = {
  available: boolean;
  capabilities: ComputeOfferCapabilities;
  compute: Compute;
  expiresAt: Date | null;
  observedAt: Date;
  priceUsdHr: number;
  /**
   * Opaque compute-provider identifier. Supported values are deployment-specific.
   */
  provider: string;
  providerSku: string;
  region: Region;
};

/** @internal */
export const ComputeOfferCapabilities$inboundSchema: z.ZodType<
  ComputeOfferCapabilities,
  z.ZodTypeDef,
  unknown
> = z.object({
  custom_image: z.boolean(),
  http_ports: z.boolean(),
  managed_service: z.boolean(),
  multi_node: z.boolean(),
  persistent_volume: z.boolean(),
  scale_to_zero: z.boolean(),
  shared_volume: z.boolean(),
  ssh: z.boolean(),
  tcp_ports: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    "custom_image": "customImage",
    "http_ports": "httpPorts",
    "managed_service": "managedService",
    "multi_node": "multiNode",
    "persistent_volume": "persistentVolume",
    "scale_to_zero": "scaleToZero",
    "shared_volume": "sharedVolume",
    "tcp_ports": "tcpPorts",
  });
});
/** @internal */
export type ComputeOfferCapabilities$Outbound = {
  custom_image: boolean;
  http_ports: boolean;
  managed_service: boolean;
  multi_node: boolean;
  persistent_volume: boolean;
  scale_to_zero: boolean;
  shared_volume: boolean;
  ssh: boolean;
  tcp_ports: boolean;
};

/** @internal */
export const ComputeOfferCapabilities$outboundSchema: z.ZodType<
  ComputeOfferCapabilities$Outbound,
  z.ZodTypeDef,
  ComputeOfferCapabilities
> = z.object({
  customImage: z.boolean(),
  httpPorts: z.boolean(),
  managedService: z.boolean(),
  multiNode: z.boolean(),
  persistentVolume: z.boolean(),
  scaleToZero: z.boolean(),
  sharedVolume: z.boolean(),
  ssh: z.boolean(),
  tcpPorts: z.boolean(),
}).transform((v) => {
  return remap$(v, {
    customImage: "custom_image",
    httpPorts: "http_ports",
    managedService: "managed_service",
    multiNode: "multi_node",
    persistentVolume: "persistent_volume",
    scaleToZero: "scale_to_zero",
    sharedVolume: "shared_volume",
    tcpPorts: "tcp_ports",
  });
});

export function computeOfferCapabilitiesToJSON(
  computeOfferCapabilities: ComputeOfferCapabilities,
): string {
  return JSON.stringify(
    ComputeOfferCapabilities$outboundSchema.parse(computeOfferCapabilities),
  );
}
export function computeOfferCapabilitiesFromJSON(
  jsonString: string,
): SafeParseResult<ComputeOfferCapabilities, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeOfferCapabilities$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeOfferCapabilities' from JSON`,
  );
}

/** @internal */
export const Compute$inboundSchema: z.ZodType<Compute, z.ZodTypeDef, unknown> =
  z.object({
    accelerator: z.string(),
    ephemeral_disk_gb: z.number().int(),
    gpu_count: z.number().int(),
    gpu_memory_gb: z.number().int(),
    instance_count: z.number().int(),
    interconnect: z.string().optional(),
    memory_gb: z.number().int(),
    vcpus: z.number().int(),
  }).transform((v) => {
    return remap$(v, {
      "ephemeral_disk_gb": "ephemeralDiskGb",
      "gpu_count": "gpuCount",
      "gpu_memory_gb": "gpuMemoryGb",
      "instance_count": "instanceCount",
      "memory_gb": "memoryGb",
    });
  });
/** @internal */
export type Compute$Outbound = {
  accelerator: string;
  ephemeral_disk_gb: number;
  gpu_count: number;
  gpu_memory_gb: number;
  instance_count: number;
  interconnect?: string | undefined;
  memory_gb: number;
  vcpus: number;
};

/** @internal */
export const Compute$outboundSchema: z.ZodType<
  Compute$Outbound,
  z.ZodTypeDef,
  Compute
> = z.object({
  accelerator: z.string(),
  ephemeralDiskGb: z.number().int(),
  gpuCount: z.number().int(),
  gpuMemoryGb: z.number().int(),
  instanceCount: z.number().int(),
  interconnect: z.string().optional(),
  memoryGb: z.number().int(),
  vcpus: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    ephemeralDiskGb: "ephemeral_disk_gb",
    gpuCount: "gpu_count",
    gpuMemoryGb: "gpu_memory_gb",
    instanceCount: "instance_count",
    memoryGb: "memory_gb",
  });
});

export function computeToJSON(compute: Compute): string {
  return JSON.stringify(Compute$outboundSchema.parse(compute));
}
export function computeFromJSON(
  jsonString: string,
): SafeParseResult<Compute, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Compute$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Compute' from JSON`,
  );
}

/** @internal */
export const Region$inboundSchema: z.ZodType<Region, z.ZodTypeDef, unknown> = z
  .object({
    country: z.string().optional(),
    name: z.string(),
  });
/** @internal */
export type Region$Outbound = {
  country?: string | undefined;
  name: string;
};

/** @internal */
export const Region$outboundSchema: z.ZodType<
  Region$Outbound,
  z.ZodTypeDef,
  Region
> = z.object({
  country: z.string().optional(),
  name: z.string(),
});

export function regionToJSON(region: Region): string {
  return JSON.stringify(Region$outboundSchema.parse(region));
}
export function regionFromJSON(
  jsonString: string,
): SafeParseResult<Region, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Region$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Region' from JSON`,
  );
}

/** @internal */
export const ComputeOffer$inboundSchema: z.ZodType<
  ComputeOffer,
  z.ZodTypeDef,
  unknown
> = z.object({
  available: z.boolean(),
  capabilities: z.lazy(() => ComputeOfferCapabilities$inboundSchema),
  compute: z.lazy(() => Compute$inboundSchema),
  expires_at: z.nullable(
    z.string().datetime({ offset: true }).transform(v => new Date(v)),
  ),
  observed_at: z.string().datetime({ offset: true }).transform(v =>
    new Date(v)
  ),
  price_usd_hr: z.number(),
  provider: z.string(),
  provider_sku: z.string(),
  region: z.lazy(() => Region$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "expires_at": "expiresAt",
    "observed_at": "observedAt",
    "price_usd_hr": "priceUsdHr",
    "provider_sku": "providerSku",
  });
});
/** @internal */
export type ComputeOffer$Outbound = {
  available: boolean;
  capabilities: ComputeOfferCapabilities$Outbound;
  compute: Compute$Outbound;
  expires_at: string | null;
  observed_at: string;
  price_usd_hr: number;
  provider: string;
  provider_sku: string;
  region: Region$Outbound;
};

/** @internal */
export const ComputeOffer$outboundSchema: z.ZodType<
  ComputeOffer$Outbound,
  z.ZodTypeDef,
  ComputeOffer
> = z.object({
  available: z.boolean(),
  capabilities: z.lazy(() => ComputeOfferCapabilities$outboundSchema),
  compute: z.lazy(() => Compute$outboundSchema),
  expiresAt: z.nullable(z.date().transform(v => v.toISOString())),
  observedAt: z.date().transform(v => v.toISOString()),
  priceUsdHr: z.number(),
  provider: z.string(),
  providerSku: z.string(),
  region: z.lazy(() => Region$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    expiresAt: "expires_at",
    observedAt: "observed_at",
    priceUsdHr: "price_usd_hr",
    providerSku: "provider_sku",
  });
});

export function computeOfferToJSON(computeOffer: ComputeOffer): string {
  return JSON.stringify(ComputeOffer$outboundSchema.parse(computeOffer));
}
export function computeOfferFromJSON(
  jsonString: string,
): SafeParseResult<ComputeOffer, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeOffer$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeOffer' from JSON`,
  );
}