/*
 * 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";
import {
  ComputeEndpoint,
  ComputeEndpoint$inboundSchema,
  ComputeEndpoint$Outbound,
  ComputeEndpoint$outboundSchema,
} from "./computeendpoint.js";
import {
  ComputeHardware,
  ComputeHardware$inboundSchema,
  ComputeHardware$Outbound,
  ComputeHardware$outboundSchema,
} from "./computehardware.js";
import {
  ComputeInstanceState,
  ComputeInstanceState$inboundSchema,
  ComputeInstanceState$outboundSchema,
} from "./computeinstancestate.js";
import {
  ComputeReason,
  ComputeReason$inboundSchema,
  ComputeReason$Outbound,
  ComputeReason$outboundSchema,
} from "./computereason.js";
import {
  ComputeSSH,
  ComputeSSH$inboundSchema,
  ComputeSSH$Outbound,
  ComputeSSH$outboundSchema,
} from "./computessh.js";

export type ComputeInstance = {
  createdAt?: Date | undefined;
  endpoints: Array<ComputeEndpoint>;
  exitCode?: number | undefined;
  hardware: ComputeHardware;
  host?: string | undefined;
  id: string;
  priceUsdHr?: number | undefined;
  privateHost?: string | undefined;
  providerId: string;
  /**
   * Provider-native type, such as pod, instant_cluster_pod, or instance.
   */
  providerResourceType: string;
  rank?: number | undefined;
  ready?: boolean | undefined;
  readyAt?: Date | undefined;
  reason?: ComputeReason | undefined;
  region?: string | undefined;
  replicaIndex?: number | undefined;
  ssh?: ComputeSSH | undefined;
  startedAt?: Date | undefined;
  state: ComputeInstanceState;
  terminalAt?: Date | undefined;
};

/** @internal */
export const ComputeInstance$inboundSchema: z.ZodType<
  ComputeInstance,
  z.ZodTypeDef,
  unknown
> = z.object({
  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
    .optional(),
  endpoints: z.array(ComputeEndpoint$inboundSchema),
  exit_code: z.number().int().optional(),
  hardware: ComputeHardware$inboundSchema,
  host: z.string().optional(),
  id: z.string(),
  price_usd_hr: z.number().optional(),
  private_host: z.string().optional(),
  provider_id: z.string(),
  provider_resource_type: z.string(),
  rank: z.number().int().optional(),
  ready: z.boolean().optional(),
  ready_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
    .optional(),
  reason: ComputeReason$inboundSchema.optional(),
  region: z.string().optional(),
  replica_index: z.number().int().optional(),
  ssh: ComputeSSH$inboundSchema.optional(),
  started_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
    .optional(),
  state: ComputeInstanceState$inboundSchema,
  terminal_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
    .optional(),
}).transform((v) => {
  return remap$(v, {
    "created_at": "createdAt",
    "exit_code": "exitCode",
    "price_usd_hr": "priceUsdHr",
    "private_host": "privateHost",
    "provider_id": "providerId",
    "provider_resource_type": "providerResourceType",
    "ready_at": "readyAt",
    "replica_index": "replicaIndex",
    "started_at": "startedAt",
    "terminal_at": "terminalAt",
  });
});
/** @internal */
export type ComputeInstance$Outbound = {
  created_at?: string | undefined;
  endpoints: Array<ComputeEndpoint$Outbound>;
  exit_code?: number | undefined;
  hardware: ComputeHardware$Outbound;
  host?: string | undefined;
  id: string;
  price_usd_hr?: number | undefined;
  private_host?: string | undefined;
  provider_id: string;
  provider_resource_type: string;
  rank?: number | undefined;
  ready?: boolean | undefined;
  ready_at?: string | undefined;
  reason?: ComputeReason$Outbound | undefined;
  region?: string | undefined;
  replica_index?: number | undefined;
  ssh?: ComputeSSH$Outbound | undefined;
  started_at?: string | undefined;
  state: string;
  terminal_at?: string | undefined;
};

/** @internal */
export const ComputeInstance$outboundSchema: z.ZodType<
  ComputeInstance$Outbound,
  z.ZodTypeDef,
  ComputeInstance
> = z.object({
  createdAt: z.date().transform(v => v.toISOString()).optional(),
  endpoints: z.array(ComputeEndpoint$outboundSchema),
  exitCode: z.number().int().optional(),
  hardware: ComputeHardware$outboundSchema,
  host: z.string().optional(),
  id: z.string(),
  priceUsdHr: z.number().optional(),
  privateHost: z.string().optional(),
  providerId: z.string(),
  providerResourceType: z.string(),
  rank: z.number().int().optional(),
  ready: z.boolean().optional(),
  readyAt: z.date().transform(v => v.toISOString()).optional(),
  reason: ComputeReason$outboundSchema.optional(),
  region: z.string().optional(),
  replicaIndex: z.number().int().optional(),
  ssh: ComputeSSH$outboundSchema.optional(),
  startedAt: z.date().transform(v => v.toISOString()).optional(),
  state: ComputeInstanceState$outboundSchema,
  terminalAt: z.date().transform(v => v.toISOString()).optional(),
}).transform((v) => {
  return remap$(v, {
    createdAt: "created_at",
    exitCode: "exit_code",
    priceUsdHr: "price_usd_hr",
    privateHost: "private_host",
    providerId: "provider_id",
    providerResourceType: "provider_resource_type",
    readyAt: "ready_at",
    replicaIndex: "replica_index",
    startedAt: "started_at",
    terminalAt: "terminal_at",
  });
});

export function computeInstanceToJSON(
  computeInstance: ComputeInstance,
): string {
  return JSON.stringify(ComputeInstance$outboundSchema.parse(computeInstance));
}
export function computeInstanceFromJSON(
  jsonString: string,
): SafeParseResult<ComputeInstance, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeInstance$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeInstance' from JSON`,
  );
}