@meetkai/mka1 0.51.16 → 0.51.17

package/src/mcp-server/tools/servingAcceleratorsGet.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { servingAcceleratorsGet } from "../../funcs/servingAcceleratorsGet.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.GetAcceleratorRequest$inboundSchema,
+};
+
+export const tool$servingAcceleratorsGet: ToolDefinition<typeof args> = {
+  name: "serving-accelerators-get",
+  description: `Get an accelerator type
+
+Retrieve one accelerator type from the curated catalog, including its workload affinity, placements, and live market fields when available.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await servingAcceleratorsGet(
+      client,
+      args.request,
+      { fetchOptions: { signal: ctx.signal } },
+    ).$inspect();
+
+    if (!result.ok) {
+      return {
+        content: [{ type: "text", text: result.error.message }],
+        isError: true,
+      };
+    }
+
+    const value = result.value;
+
+    return formatResult(value, apiCall);
+  },
+};

package/src/models/components/acceleratoravailability.ts

@@ -0,0 +1,146 @@
+/*
+ * 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";
+import {
+  AcceleratorAvailabilityBucket,
+  AcceleratorAvailabilityBucket$inboundSchema,
+  AcceleratorAvailabilityBucket$Outbound,
+  AcceleratorAvailabilityBucket$outboundSchema,
+} from "./acceleratoravailabilitybucket.js";
+import {
+  AcceleratorHourOfDaySlot,
+  AcceleratorHourOfDaySlot$inboundSchema,
+  AcceleratorHourOfDaySlot$Outbound,
+  AcceleratorHourOfDaySlot$outboundSchema,
+} from "./acceleratorhourofdayslot.js";
+import {
+  AcceleratorProviderAvailability,
+  AcceleratorProviderAvailability$inboundSchema,
+  AcceleratorProviderAvailability$Outbound,
+  AcceleratorProviderAvailability$outboundSchema,
+} from "./acceleratorprovideravailability.js";
+
+export const AcceleratorAvailabilityClass = {
+  Gpu: "gpu",
+  Cpu: "cpu",
+} as const;
+export type AcceleratorAvailabilityClass = ClosedEnum<
+  typeof AcceleratorAvailabilityClass
+>;
+
+export const Window = {
+  TwentyFourh: "24h",
+  Sevend: "7d",
+  Thirtyd: "30d",
+} as const;
+export type Window = ClosedEnum<typeof Window>;
+
+/**
+ * Bucketed availability time series for one accelerator over a window, served exclusively from hourly rollups. Estimates are honest or absent — never extrapolated past observed polls.
+ */
+export type AcceleratorAvailability = {
+  /**
+   * Hourly buckets covering polled hours of the window, oldest first. Empty when no observation in the window carried this accelerator anywhere: an honest no-data answer, never a series of fabricated zeros.
+   */
+  buckets: Array<AcceleratorAvailabilityBucket>;
+  /**
+   * Present only when the cluster does not anonymize providers; with anonymity on, only the cross-provider aggregate ships.
+   */
+  byProvider?: Array<AcceleratorProviderAvailability> | undefined;
+  class: AcceleratorAvailabilityClass;
+  /**
+   * 24-slot UTC hour-of-day profile merged across the window. Empty when buckets is empty.
+   */
+  hourOfDay: Array<AcceleratorHourOfDaySlot>;
+  name: string;
+  window: Window;
+};
+
+/** @internal */
+export const AcceleratorAvailabilityClass$inboundSchema: z.ZodNativeEnum<
+  typeof AcceleratorAvailabilityClass
+> = z.nativeEnum(AcceleratorAvailabilityClass);
+/** @internal */
+export const AcceleratorAvailabilityClass$outboundSchema: z.ZodNativeEnum<
+  typeof AcceleratorAvailabilityClass
+> = AcceleratorAvailabilityClass$inboundSchema;
+
+/** @internal */
+export const Window$inboundSchema: z.ZodNativeEnum<typeof Window> = z
+  .nativeEnum(Window);
+/** @internal */
+export const Window$outboundSchema: z.ZodNativeEnum<typeof Window> =
+  Window$inboundSchema;
+
+/** @internal */
+export const AcceleratorAvailability$inboundSchema: z.ZodType<
+  AcceleratorAvailability,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  buckets: z.array(AcceleratorAvailabilityBucket$inboundSchema),
+  by_provider: z.array(AcceleratorProviderAvailability$inboundSchema)
+    .optional(),
+  class: AcceleratorAvailabilityClass$inboundSchema,
+  hour_of_day: z.array(AcceleratorHourOfDaySlot$inboundSchema),
+  name: z.string(),
+  window: Window$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "by_provider": "byProvider",
+    "hour_of_day": "hourOfDay",
+  });
+});
+/** @internal */
+export type AcceleratorAvailability$Outbound = {
+  buckets: Array<AcceleratorAvailabilityBucket$Outbound>;
+  by_provider?: Array<AcceleratorProviderAvailability$Outbound> | undefined;
+  class: string;
+  hour_of_day: Array<AcceleratorHourOfDaySlot$Outbound>;
+  name: string;
+  window: string;
+};
+
+/** @internal */
+export const AcceleratorAvailability$outboundSchema: z.ZodType<
+  AcceleratorAvailability$Outbound,
+  z.ZodTypeDef,
+  AcceleratorAvailability
+> = z.object({
+  buckets: z.array(AcceleratorAvailabilityBucket$outboundSchema),
+  byProvider: z.array(AcceleratorProviderAvailability$outboundSchema)
+    .optional(),
+  class: AcceleratorAvailabilityClass$outboundSchema,
+  hourOfDay: z.array(AcceleratorHourOfDaySlot$outboundSchema),
+  name: z.string(),
+  window: Window$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    byProvider: "by_provider",
+    hourOfDay: "hour_of_day",
+  });
+});
+
+export function acceleratorAvailabilityToJSON(
+  acceleratorAvailability: AcceleratorAvailability,
+): string {
+  return JSON.stringify(
+    AcceleratorAvailability$outboundSchema.parse(acceleratorAvailability),
+  );
+}
+export function acceleratorAvailabilityFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorAvailability, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorAvailability$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorAvailability' from JSON`,
+  );
+}

package/src/models/components/acceleratoravailabilitybucket.ts

@@ -0,0 +1,103 @@
+/*
+ * 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 {
+  AvailabilityPriceBand,
+  AvailabilityPriceBand$inboundSchema,
+  AvailabilityPriceBand$Outbound,
+  AvailabilityPriceBand$outboundSchema,
+} from "./availabilitypriceband.js";
+
+/**
+ * One hourly availability bucket for an accelerator, aggregated across anonymous providers.
+ */
+export type AcceleratorAvailabilityBucket = {
+  /**
+   * Fraction of successful capacity polls in the bucket at which matching capacity was available. Hours polled without any matching observation read 0.
+   */
+  availabilityRatio: number;
+  /**
+   * UTC start of the hourly bucket.
+   */
+  bucketStart: Date;
+  /**
+   * Successful poll observations that carried a matching configuration in this bucket (0 when the accelerator was absent for the whole hour).
+   */
+  presentPolls: number;
+  /**
+   * Null when the bucket has no priced observations; prices are never extrapolated.
+   */
+  priceBand?: AvailabilityPriceBand | null | undefined;
+};
+
+/** @internal */
+export const AcceleratorAvailabilityBucket$inboundSchema: z.ZodType<
+  AcceleratorAvailabilityBucket,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  availability_ratio: z.number(),
+  bucket_start: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  present_polls: z.number().int(),
+  price_band: z.nullable(AvailabilityPriceBand$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "availability_ratio": "availabilityRatio",
+    "bucket_start": "bucketStart",
+    "present_polls": "presentPolls",
+    "price_band": "priceBand",
+  });
+});
+/** @internal */
+export type AcceleratorAvailabilityBucket$Outbound = {
+  availability_ratio: number;
+  bucket_start: string;
+  present_polls: number;
+  price_band?: AvailabilityPriceBand$Outbound | null | undefined;
+};
+
+/** @internal */
+export const AcceleratorAvailabilityBucket$outboundSchema: z.ZodType<
+  AcceleratorAvailabilityBucket$Outbound,
+  z.ZodTypeDef,
+  AcceleratorAvailabilityBucket
+> = z.object({
+  availabilityRatio: z.number(),
+  bucketStart: z.date().transform(v => v.toISOString()),
+  presentPolls: z.number().int(),
+  priceBand: z.nullable(AvailabilityPriceBand$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    availabilityRatio: "availability_ratio",
+    bucketStart: "bucket_start",
+    presentPolls: "present_polls",
+    priceBand: "price_band",
+  });
+});
+
+export function acceleratorAvailabilityBucketToJSON(
+  acceleratorAvailabilityBucket: AcceleratorAvailabilityBucket,
+): string {
+  return JSON.stringify(
+    AcceleratorAvailabilityBucket$outboundSchema.parse(
+      acceleratorAvailabilityBucket,
+    ),
+  );
+}
+export function acceleratorAvailabilityBucketFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorAvailabilityBucket, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorAvailabilityBucket$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorAvailabilityBucket' from JSON`,
+  );
+}

package/src/models/components/acceleratorhourofdayslot.ts

@@ -0,0 +1,80 @@
+/*
+ * 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";
+
+/**
+ * One slot of the 24-slot hour-of-day availability profile.
+ */
+export type AcceleratorHourOfDaySlot = {
+  /**
+   * Unweighted mean of the window's hourly availability ratios that fall on this hour of day. Meaningless when samples is 0.
+   */
+  availabilityRatio: number;
+  /**
+   * UTC hour of day.
+   */
+  hour: number;
+  /**
+   * Number of window buckets contributing to this slot. 0 means no evidence for this hour of day.
+   */
+  samples: number;
+};
+
+/** @internal */
+export const AcceleratorHourOfDaySlot$inboundSchema: z.ZodType<
+  AcceleratorHourOfDaySlot,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  availability_ratio: z.number(),
+  hour: z.number().int(),
+  samples: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "availability_ratio": "availabilityRatio",
+  });
+});
+/** @internal */
+export type AcceleratorHourOfDaySlot$Outbound = {
+  availability_ratio: number;
+  hour: number;
+  samples: number;
+};
+
+/** @internal */
+export const AcceleratorHourOfDaySlot$outboundSchema: z.ZodType<
+  AcceleratorHourOfDaySlot$Outbound,
+  z.ZodTypeDef,
+  AcceleratorHourOfDaySlot
+> = z.object({
+  availabilityRatio: z.number(),
+  hour: z.number().int(),
+  samples: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    availabilityRatio: "availability_ratio",
+  });
+});
+
+export function acceleratorHourOfDaySlotToJSON(
+  acceleratorHourOfDaySlot: AcceleratorHourOfDaySlot,
+): string {
+  return JSON.stringify(
+    AcceleratorHourOfDaySlot$outboundSchema.parse(acceleratorHourOfDaySlot),
+  );
+}
+export function acceleratorHourOfDaySlotFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorHourOfDaySlot, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorHourOfDaySlot$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorHourOfDaySlot' from JSON`,
+  );
+}

package/src/models/components/acceleratorprovideravailability.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AcceleratorAvailabilityBucket,
+  AcceleratorAvailabilityBucket$inboundSchema,
+  AcceleratorAvailabilityBucket$Outbound,
+  AcceleratorAvailabilityBucket$outboundSchema,
+} from "./acceleratoravailabilitybucket.js";
+
+/**
+ * Per-provider breakdown of the same buckets. Served only when the cluster does not anonymize providers.
+ */
+export type AcceleratorProviderAvailability = {
+  buckets: Array<AcceleratorAvailabilityBucket>;
+  provider: string;
+};
+
+/** @internal */
+export const AcceleratorProviderAvailability$inboundSchema: z.ZodType<
+  AcceleratorProviderAvailability,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  buckets: z.array(AcceleratorAvailabilityBucket$inboundSchema),
+  provider: z.string(),
+});
+/** @internal */
+export type AcceleratorProviderAvailability$Outbound = {
+  buckets: Array<AcceleratorAvailabilityBucket$Outbound>;
+  provider: string;
+};
+
+/** @internal */
+export const AcceleratorProviderAvailability$outboundSchema: z.ZodType<
+  AcceleratorProviderAvailability$Outbound,
+  z.ZodTypeDef,
+  AcceleratorProviderAvailability
+> = z.object({
+  buckets: z.array(AcceleratorAvailabilityBucket$outboundSchema),
+  provider: z.string(),
+});
+
+export function acceleratorProviderAvailabilityToJSON(
+  acceleratorProviderAvailability: AcceleratorProviderAvailability,
+): string {
+  return JSON.stringify(
+    AcceleratorProviderAvailability$outboundSchema.parse(
+      acceleratorProviderAvailability,
+    ),
+  );
+}
+export function acceleratorProviderAvailabilityFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorProviderAvailability, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorProviderAvailability$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorProviderAvailability' from JSON`,
+  );
+}

package/src/models/components/acceleratortype.ts

@@ -14,20 +14,54 @@ import {
   AcceleratorPriceBand$Outbound,
   AcceleratorPriceBand$outboundSchema,
 } from "./acceleratorpriceband.js";
+import {
+  AcceleratorWorkloadAffinity,
+  AcceleratorWorkloadAffinity$inboundSchema,
+  AcceleratorWorkloadAffinity$Outbound,
+  AcceleratorWorkloadAffinity$outboundSchema,
+} from "./acceleratorworkloadaffinity.js";
 import {
   Acquirability,
   Acquirability$inboundSchema,
   Acquirability$outboundSchema,
 } from "./acquirability.js";
 
+/**
+ * Coarse accelerator class. npu/tpu are reserved for future catalog entries.
+ */
+export const Class = {
+  Gpu: "gpu",
+  Cpu: "cpu",
+} as const;
+/**
+ * Coarse accelerator class. npu/tpu are reserved for future catalog entries.
+ */
+export type Class = ClosedEnum<typeof Class>;
+
+/**
+ * Deprecated: use class. Retained for SDK compatibility until the next breaking conventions pass.
+ *
+ * @deprecated enum: This will be removed in a future release, please migrate away from it as soon as possible.
+ */
 export const Kind = {
   Gpu: "gpu",
   Npu: "npu",
   Tpu: "tpu",
   Other: "other",
 } as const;
+/**
+ * Deprecated: use class. Retained for SDK compatibility until the next breaking conventions pass.
+ *
+ * @deprecated enum: This will be removed in a future release, please migrate away from it as soon as possible.
+ */
 export type Kind = ClosedEnum<typeof Kind>;
 
+export const Placements = {
+  Internal: "internal",
+  External: "external",
+} as const;
+export type Placements = ClosedEnum<typeof Placements>;
+
 /**
  * An offered accelerator type in the catalog.
  */
@@ -40,24 +74,52 @@ export type AcceleratorType = {
    * Configurations acquirable now (0 when offered is false). Absent when live market data is unavailable.
    */
   acquirableCount?: number | undefined;
+  /**
+   * Coarse accelerator class. npu/tpu are reserved for future catalog entries.
+   */
+  class: Class;
+  /**
+   * Deprecated: use class. Retained for SDK compatibility until the next breaking conventions pass.
+   *
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
   kind?: Kind | undefined;
   /**
-   * Max accelerators of this type per replica
+   * Max accelerators of this type per replica. For class cpu the unit is vCPUs: the maximum rentable vCPU count per replica.
    */
   maxCount: number;
-  memoryGb: number;
+  /**
+   * Per-accelerator memory in GB. Absent for class cpu: CPU capacity is sized per request (min_vcpus/min_mem_gb), not by a fixed module.
+   */
+  memoryGb?: number | undefined;
   name: string;
   /**
    * Whether any capacity acquirable right now matches this type. Absent when live market data is unavailable.
    */
   offered?: boolean | undefined;
+  /**
+   * Placements where this accelerator exists. All catalog entries are external (marketplace-acquired) today; internal arrives with private-cluster inventory.
+   */
+  placements: Array<Placements>;
   /**
    * USD-per-hour price band across configurations acquirable now for an accelerator type.
    */
   priceUsdHr?: AcceleratorPriceBand | undefined;
   vendor: string;
+  /**
+   * Per-workload suitability ratings for an accelerator type, seeded from the training hardware matrix.
+   */
+  workloadAffinity: AcceleratorWorkloadAffinity;
 };
 
+/** @internal */
+export const Class$inboundSchema: z.ZodNativeEnum<typeof Class> = z.nativeEnum(
+  Class,
+);
+/** @internal */
+export const Class$outboundSchema: z.ZodNativeEnum<typeof Class> =
+  Class$inboundSchema;
+
 /** @internal */
 export const Kind$inboundSchema: z.ZodNativeEnum<typeof Kind> = z.nativeEnum(
   Kind,
@@ -66,6 +128,13 @@ export const Kind$inboundSchema: z.ZodNativeEnum<typeof Kind> = z.nativeEnum(
 export const Kind$outboundSchema: z.ZodNativeEnum<typeof Kind> =
   Kind$inboundSchema;
 
+/** @internal */
+export const Placements$inboundSchema: z.ZodNativeEnum<typeof Placements> = z
+  .nativeEnum(Placements);
+/** @internal */
+export const Placements$outboundSchema: z.ZodNativeEnum<typeof Placements> =
+  Placements$inboundSchema;
+
 /** @internal */
 export const AcceleratorType$inboundSchema: z.ZodType<
   AcceleratorType,
@@ -74,32 +143,39 @@ export const AcceleratorType$inboundSchema: z.ZodType<
 > = z.object({
   acquirability: Acquirability$inboundSchema.optional(),
   acquirable_count: z.number().int().optional(),
+  class: Class$inboundSchema,
   kind: Kind$inboundSchema.default("gpu"),
   max_count: z.number().int(),
-  memory_gb: z.number().int(),
+  memory_gb: z.number().int().optional(),
   name: z.string(),
   offered: z.boolean().optional(),
+  placements: z.array(Placements$inboundSchema),
   price_usd_hr: AcceleratorPriceBand$inboundSchema.optional(),
   vendor: z.string(),
+  workload_affinity: AcceleratorWorkloadAffinity$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "acquirable_count": "acquirableCount",
     "max_count": "maxCount",
     "memory_gb": "memoryGb",
     "price_usd_hr": "priceUsdHr",
+    "workload_affinity": "workloadAffinity",
   });
 });
 /** @internal */
 export type AcceleratorType$Outbound = {
   acquirability?: string | undefined;
   acquirable_count?: number | undefined;
+  class: string;
   kind: string;
   max_count: number;
-  memory_gb: number;
+  memory_gb?: number | undefined;
   name: string;
   offered?: boolean | undefined;
+  placements: Array<string>;
   price_usd_hr?: AcceleratorPriceBand$Outbound | undefined;
   vendor: string;
+  workload_affinity: AcceleratorWorkloadAffinity$Outbound;
 };
 
 /** @internal */
@@ -110,19 +186,23 @@ export const AcceleratorType$outboundSchema: z.ZodType<
 > = z.object({
   acquirability: Acquirability$outboundSchema.optional(),
   acquirableCount: z.number().int().optional(),
+  class: Class$outboundSchema,
   kind: Kind$outboundSchema.default("gpu"),
   maxCount: z.number().int(),
-  memoryGb: z.number().int(),
+  memoryGb: z.number().int().optional(),
   name: z.string(),
   offered: z.boolean().optional(),
+  placements: z.array(Placements$outboundSchema),
   priceUsdHr: AcceleratorPriceBand$outboundSchema.optional(),
   vendor: z.string(),
+  workloadAffinity: AcceleratorWorkloadAffinity$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     acquirableCount: "acquirable_count",
     maxCount: "max_count",
     memoryGb: "memory_gb",
     priceUsdHr: "price_usd_hr",
+    workloadAffinity: "workload_affinity",
   });
 });
 

package/src/models/components/acceleratorworkloadaffinity.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AffinityRating,
+  AffinityRating$inboundSchema,
+  AffinityRating$outboundSchema,
+} from "./affinityrating.js";
+
+/**
+ * Per-workload suitability ratings for an accelerator type, seeded from the training hardware matrix.
+ */
+export type AcceleratorWorkloadAffinity = {
+  /**
+   * How well an accelerator suits a workload class. Catalog data, not a scheduling guarantee.
+   */
+  serving: AffinityRating;
+  /**
+   * How well an accelerator suits a workload class. Catalog data, not a scheduling guarantee.
+   */
+  training: AffinityRating;
+};
+
+/** @internal */
+export const AcceleratorWorkloadAffinity$inboundSchema: z.ZodType<
+  AcceleratorWorkloadAffinity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  serving: AffinityRating$inboundSchema,
+  training: AffinityRating$inboundSchema,
+});
+/** @internal */
+export type AcceleratorWorkloadAffinity$Outbound = {
+  serving: string;
+  training: string;
+};
+
+/** @internal */
+export const AcceleratorWorkloadAffinity$outboundSchema: z.ZodType<
+  AcceleratorWorkloadAffinity$Outbound,
+  z.ZodTypeDef,
+  AcceleratorWorkloadAffinity
+> = z.object({
+  serving: AffinityRating$outboundSchema,
+  training: AffinityRating$outboundSchema,
+});
+
+export function acceleratorWorkloadAffinityToJSON(
+  acceleratorWorkloadAffinity: AcceleratorWorkloadAffinity,
+): string {
+  return JSON.stringify(
+    AcceleratorWorkloadAffinity$outboundSchema.parse(
+      acceleratorWorkloadAffinity,
+    ),
+  );
+}
+export function acceleratorWorkloadAffinityFromJSON(
+  jsonString: string,
+): SafeParseResult<AcceleratorWorkloadAffinity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AcceleratorWorkloadAffinity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AcceleratorWorkloadAffinity' from JSON`,
+  );
+}