/*
 * 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 {
  ComputeResourceType,
  ComputeResourceType$inboundSchema,
  ComputeResourceType$outboundSchema,
} from "./computeresourcetype.js";

export type CostBreakdownUsd = {
  compute: number;
  volume: number;
};

export type ComputeUsageData = {
  accruedUsd: number;
  billableSeconds: number;
  costBreakdownUsd?: CostBreakdownUsd | undefined;
  name: string;
  resourceId: string;
  resourceType: ComputeResourceType;
};

export type ComputeUsageSummary = {
  jobUsd: number;
  serviceUsd: number;
  totalUsd: number;
};

export type Window = {
  from: Date;
  to: Date;
};

export type ComputeUsage = {
  data: Array<ComputeUsageData>;
  nextCursor: string | null;
  summary: ComputeUsageSummary;
  total: number;
  window: Window;
};

/** @internal */
export const CostBreakdownUsd$inboundSchema: z.ZodType<
  CostBreakdownUsd,
  z.ZodTypeDef,
  unknown
> = z.object({
  compute: z.number(),
  volume: z.number(),
});
/** @internal */
export type CostBreakdownUsd$Outbound = {
  compute: number;
  volume: number;
};

/** @internal */
export const CostBreakdownUsd$outboundSchema: z.ZodType<
  CostBreakdownUsd$Outbound,
  z.ZodTypeDef,
  CostBreakdownUsd
> = z.object({
  compute: z.number(),
  volume: z.number(),
});

export function costBreakdownUsdToJSON(
  costBreakdownUsd: CostBreakdownUsd,
): string {
  return JSON.stringify(
    CostBreakdownUsd$outboundSchema.parse(costBreakdownUsd),
  );
}
export function costBreakdownUsdFromJSON(
  jsonString: string,
): SafeParseResult<CostBreakdownUsd, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CostBreakdownUsd$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CostBreakdownUsd' from JSON`,
  );
}

/** @internal */
export const ComputeUsageData$inboundSchema: z.ZodType<
  ComputeUsageData,
  z.ZodTypeDef,
  unknown
> = z.object({
  accrued_usd: z.number(),
  billable_seconds: z.number().int(),
  cost_breakdown_usd: z.lazy(() => CostBreakdownUsd$inboundSchema).optional(),
  name: z.string(),
  resource_id: z.string(),
  resource_type: ComputeResourceType$inboundSchema,
}).transform((v) => {
  return remap$(v, {
    "accrued_usd": "accruedUsd",
    "billable_seconds": "billableSeconds",
    "cost_breakdown_usd": "costBreakdownUsd",
    "resource_id": "resourceId",
    "resource_type": "resourceType",
  });
});
/** @internal */
export type ComputeUsageData$Outbound = {
  accrued_usd: number;
  billable_seconds: number;
  cost_breakdown_usd?: CostBreakdownUsd$Outbound | undefined;
  name: string;
  resource_id: string;
  resource_type: string;
};

/** @internal */
export const ComputeUsageData$outboundSchema: z.ZodType<
  ComputeUsageData$Outbound,
  z.ZodTypeDef,
  ComputeUsageData
> = z.object({
  accruedUsd: z.number(),
  billableSeconds: z.number().int(),
  costBreakdownUsd: z.lazy(() => CostBreakdownUsd$outboundSchema).optional(),
  name: z.string(),
  resourceId: z.string(),
  resourceType: ComputeResourceType$outboundSchema,
}).transform((v) => {
  return remap$(v, {
    accruedUsd: "accrued_usd",
    billableSeconds: "billable_seconds",
    costBreakdownUsd: "cost_breakdown_usd",
    resourceId: "resource_id",
    resourceType: "resource_type",
  });
});

export function computeUsageDataToJSON(
  computeUsageData: ComputeUsageData,
): string {
  return JSON.stringify(
    ComputeUsageData$outboundSchema.parse(computeUsageData),
  );
}
export function computeUsageDataFromJSON(
  jsonString: string,
): SafeParseResult<ComputeUsageData, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeUsageData$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeUsageData' from JSON`,
  );
}

/** @internal */
export const ComputeUsageSummary$inboundSchema: z.ZodType<
  ComputeUsageSummary,
  z.ZodTypeDef,
  unknown
> = z.object({
  job_usd: z.number(),
  service_usd: z.number(),
  total_usd: z.number(),
}).transform((v) => {
  return remap$(v, {
    "job_usd": "jobUsd",
    "service_usd": "serviceUsd",
    "total_usd": "totalUsd",
  });
});
/** @internal */
export type ComputeUsageSummary$Outbound = {
  job_usd: number;
  service_usd: number;
  total_usd: number;
};

/** @internal */
export const ComputeUsageSummary$outboundSchema: z.ZodType<
  ComputeUsageSummary$Outbound,
  z.ZodTypeDef,
  ComputeUsageSummary
> = z.object({
  jobUsd: z.number(),
  serviceUsd: z.number(),
  totalUsd: z.number(),
}).transform((v) => {
  return remap$(v, {
    jobUsd: "job_usd",
    serviceUsd: "service_usd",
    totalUsd: "total_usd",
  });
});

export function computeUsageSummaryToJSON(
  computeUsageSummary: ComputeUsageSummary,
): string {
  return JSON.stringify(
    ComputeUsageSummary$outboundSchema.parse(computeUsageSummary),
  );
}
export function computeUsageSummaryFromJSON(
  jsonString: string,
): SafeParseResult<ComputeUsageSummary, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeUsageSummary$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeUsageSummary' from JSON`,
  );
}

/** @internal */
export const Window$inboundSchema: z.ZodType<Window, z.ZodTypeDef, unknown> = z
  .object({
    from: z.string().datetime({ offset: true }).transform(v => new Date(v)),
    to: z.string().datetime({ offset: true }).transform(v => new Date(v)),
  });
/** @internal */
export type Window$Outbound = {
  from: string;
  to: string;
};

/** @internal */
export const Window$outboundSchema: z.ZodType<
  Window$Outbound,
  z.ZodTypeDef,
  Window
> = z.object({
  from: z.date().transform(v => v.toISOString()),
  to: z.date().transform(v => v.toISOString()),
});

export function windowToJSON(window: Window): string {
  return JSON.stringify(Window$outboundSchema.parse(window));
}
export function windowFromJSON(
  jsonString: string,
): SafeParseResult<Window, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Window$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Window' from JSON`,
  );
}

/** @internal */
export const ComputeUsage$inboundSchema: z.ZodType<
  ComputeUsage,
  z.ZodTypeDef,
  unknown
> = z.object({
  data: z.array(z.lazy(() => ComputeUsageData$inboundSchema)),
  next_cursor: z.nullable(z.string()),
  summary: z.lazy(() => ComputeUsageSummary$inboundSchema),
  total: z.number().int(),
  window: z.lazy(() => Window$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "next_cursor": "nextCursor",
  });
});
/** @internal */
export type ComputeUsage$Outbound = {
  data: Array<ComputeUsageData$Outbound>;
  next_cursor: string | null;
  summary: ComputeUsageSummary$Outbound;
  total: number;
  window: Window$Outbound;
};

/** @internal */
export const ComputeUsage$outboundSchema: z.ZodType<
  ComputeUsage$Outbound,
  z.ZodTypeDef,
  ComputeUsage
> = z.object({
  data: z.array(z.lazy(() => ComputeUsageData$outboundSchema)),
  nextCursor: z.nullable(z.string()),
  summary: z.lazy(() => ComputeUsageSummary$outboundSchema),
  total: z.number().int(),
  window: z.lazy(() => Window$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    nextCursor: "next_cursor",
  });
});

export function computeUsageToJSON(computeUsage: ComputeUsage): string {
  return JSON.stringify(ComputeUsage$outboundSchema.parse(computeUsage));
}
export function computeUsageFromJSON(
  jsonString: string,
): SafeParseResult<ComputeUsage, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeUsage$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeUsage' from JSON`,
  );
}