@meetkai/mka1 0.54.32 → 0.54.34

package/src/models/components/computeservice.ts

@@ -5,6 +5,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";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -42,6 +43,12 @@ import {
   ComputeResourceState$inboundSchema,
   ComputeResourceState$outboundSchema,
 } from "./computeresourcestate.js";
+import {
+  ComputeServiceScaling,
+  ComputeServiceScaling$inboundSchema,
+  ComputeServiceScaling$Outbound,
+  ComputeServiceScaling$outboundSchema,
+} from "./computeservicescaling.js";
 import {
   ComputeSSH,
   ComputeSSH$inboundSchema,
@@ -61,17 +68,35 @@ import {
   ComputeVolume$outboundSchema,
 } from "./computevolume.js";
 
+export const ComputeServicePricingModel = {
+  InstanceMinutes: "instance_minutes",
+  InstanceSeconds: "instance_seconds",
+} as const;
+export type ComputeServicePricingModel = ClosedEnum<
+  typeof ComputeServicePricingModel
+>;
+
+export const Health = {
+  Healthy: "healthy",
+  Warming: "warming",
+  Degraded: "degraded",
+} as const;
+export type Health = ClosedEnum<typeof Health>;
+
 export type ComputeService = {
   accruedUsd: number;
   allocatedAt?: Date | undefined;
   compute: ComputeRequest;
   createdAt: Date;
+  currentPriceUsdHr?: number | undefined;
   endpoints: Array<ComputeEndpoint>;
   hardware?: ComputeHardware | undefined;
   id: string;
+  instancePriceUsdHr?: number | undefined;
   limits: ComputeLimits;
   name?: string | undefined;
   priceUsdHr?: number | undefined;
+  pricingModel?: ComputeServicePricingModel | undefined;
   /**
    * Opaque compute-provider identifier. Supported values are deployment-specific.
    */
@@ -82,10 +107,28 @@ export type ComputeService = {
   state: ComputeResourceState;
   terminalAt: Date | null;
   volumes?: Array<ComputeStandaloneVolumeMount> | undefined;
+  health?: Health | undefined;
   ready: boolean;
+  scaling?: ComputeServiceScaling | undefined;
   volume?: ComputeVolume | undefined;
 };
 
+/** @internal */
+export const ComputeServicePricingModel$inboundSchema: z.ZodNativeEnum<
+  typeof ComputeServicePricingModel
+> = z.nativeEnum(ComputeServicePricingModel);
+/** @internal */
+export const ComputeServicePricingModel$outboundSchema: z.ZodNativeEnum<
+  typeof ComputeServicePricingModel
+> = ComputeServicePricingModel$inboundSchema;
+
+/** @internal */
+export const Health$inboundSchema: z.ZodNativeEnum<typeof Health> = z
+  .nativeEnum(Health);
+/** @internal */
+export const Health$outboundSchema: z.ZodNativeEnum<typeof Health> =
+  Health$inboundSchema;
+
 /** @internal */
 export const ComputeService$inboundSchema: z.ZodType<
   ComputeService,
@@ -98,12 +141,15 @@ export const ComputeService$inboundSchema: z.ZodType<
   ).optional(),
   compute: ComputeRequest$inboundSchema,
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  current_price_usd_hr: z.number().optional(),
   endpoints: z.array(ComputeEndpoint$inboundSchema),
   hardware: ComputeHardware$inboundSchema.optional(),
   id: z.string(),
+  instance_price_usd_hr: z.number().optional(),
   limits: ComputeLimits$inboundSchema,
   name: z.string().optional(),
   price_usd_hr: z.number().optional(),
+  pricing_model: ComputeServicePricingModel$inboundSchema.optional(),
   provider: z.string().optional(),
   reason: z.nullable(ComputeReason$inboundSchema),
   ssh: ComputeSSH$inboundSchema.optional(),
@@ -115,14 +161,19 @@ export const ComputeService$inboundSchema: z.ZodType<
     z.string().datetime({ offset: true }).transform(v => new Date(v)),
   ),
   volumes: z.array(ComputeStandaloneVolumeMount$inboundSchema).optional(),
+  health: Health$inboundSchema.optional(),
   ready: z.boolean(),
+  scaling: ComputeServiceScaling$inboundSchema.optional(),
   volume: ComputeVolume$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "accrued_usd": "accruedUsd",
     "allocated_at": "allocatedAt",
     "created_at": "createdAt",
+    "current_price_usd_hr": "currentPriceUsdHr",
+    "instance_price_usd_hr": "instancePriceUsdHr",
     "price_usd_hr": "priceUsdHr",
+    "pricing_model": "pricingModel",
     "started_at": "startedAt",
     "terminal_at": "terminalAt",
   });
@@ -133,12 +184,15 @@ export type ComputeService$Outbound = {
   allocated_at?: string | undefined;
   compute: ComputeRequest$Outbound;
   created_at: string;
+  current_price_usd_hr?: number | undefined;
   endpoints: Array<ComputeEndpoint$Outbound>;
   hardware?: ComputeHardware$Outbound | undefined;
   id: string;
+  instance_price_usd_hr?: number | undefined;
   limits: ComputeLimits$Outbound;
   name?: string | undefined;
   price_usd_hr?: number | undefined;
+  pricing_model?: string | undefined;
   provider?: string | undefined;
   reason: ComputeReason$Outbound | null;
   ssh?: ComputeSSH$Outbound | undefined;
@@ -146,7 +200,9 @@ export type ComputeService$Outbound = {
   state: string;
   terminal_at: string | null;
   volumes?: Array<ComputeStandaloneVolumeMount$Outbound> | undefined;
+  health?: string | undefined;
   ready: boolean;
+  scaling?: ComputeServiceScaling$Outbound | undefined;
   volume?: ComputeVolume$Outbound | undefined;
 };
 
@@ -160,12 +216,15 @@ export const ComputeService$outboundSchema: z.ZodType<
   allocatedAt: z.date().transform(v => v.toISOString()).optional(),
   compute: ComputeRequest$outboundSchema,
   createdAt: z.date().transform(v => v.toISOString()),
+  currentPriceUsdHr: z.number().optional(),
   endpoints: z.array(ComputeEndpoint$outboundSchema),
   hardware: ComputeHardware$outboundSchema.optional(),
   id: z.string(),
+  instancePriceUsdHr: z.number().optional(),
   limits: ComputeLimits$outboundSchema,
   name: z.string().optional(),
   priceUsdHr: z.number().optional(),
+  pricingModel: ComputeServicePricingModel$outboundSchema.optional(),
   provider: z.string().optional(),
   reason: z.nullable(ComputeReason$outboundSchema),
   ssh: ComputeSSH$outboundSchema.optional(),
@@ -173,14 +232,19 @@ export const ComputeService$outboundSchema: z.ZodType<
   state: ComputeResourceState$outboundSchema,
   terminalAt: z.nullable(z.date().transform(v => v.toISOString())),
   volumes: z.array(ComputeStandaloneVolumeMount$outboundSchema).optional(),
+  health: Health$outboundSchema.optional(),
   ready: z.boolean(),
+  scaling: ComputeServiceScaling$outboundSchema.optional(),
   volume: ComputeVolume$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     accruedUsd: "accrued_usd",
     allocatedAt: "allocated_at",
     createdAt: "created_at",
+    currentPriceUsdHr: "current_price_usd_hr",
+    instancePriceUsdHr: "instance_price_usd_hr",
     priceUsdHr: "price_usd_hr",
+    pricingModel: "pricing_model",
     startedAt: "started_at",
     terminalAt: "terminal_at",
   });

package/src/models/components/computeservicescaling.ts

@@ -0,0 +1,116 @@
+/*
+ * 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 {
+  ComputeAutoscalerState,
+  ComputeAutoscalerState$inboundSchema,
+  ComputeAutoscalerState$Outbound,
+  ComputeAutoscalerState$outboundSchema,
+} from "./computeautoscalerstate.js";
+import {
+  ComputeScalingInput,
+  ComputeScalingInput$inboundSchema,
+  ComputeScalingInput$Outbound,
+  ComputeScalingInput$outboundSchema,
+} from "./computescalinginput.js";
+import {
+  ComputeScalingReplicas,
+  ComputeScalingReplicas$inboundSchema,
+  ComputeScalingReplicas$Outbound,
+  ComputeScalingReplicas$outboundSchema,
+} from "./computescalingreplicas.js";
+
+export type ComputeServiceScaling = {
+  applied: ComputeScalingInput | null;
+  appliedAt: Date | null;
+  appliedGeneration: number;
+  autoscaler: ComputeAutoscalerState;
+  desired: ComputeScalingInput;
+  desiredGeneration: number;
+  desiredUpdatedAt: Date;
+  replicas: ComputeScalingReplicas;
+};
+
+/** @internal */
+export const ComputeServiceScaling$inboundSchema: z.ZodType<
+  ComputeServiceScaling,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  applied: z.nullable(ComputeScalingInput$inboundSchema),
+  applied_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ),
+  applied_generation: z.number().int(),
+  autoscaler: ComputeAutoscalerState$inboundSchema,
+  desired: ComputeScalingInput$inboundSchema,
+  desired_generation: z.number().int(),
+  desired_updated_at: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ),
+  replicas: ComputeScalingReplicas$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "applied_at": "appliedAt",
+    "applied_generation": "appliedGeneration",
+    "desired_generation": "desiredGeneration",
+    "desired_updated_at": "desiredUpdatedAt",
+  });
+});
+/** @internal */
+export type ComputeServiceScaling$Outbound = {
+  applied: ComputeScalingInput$Outbound | null;
+  applied_at: string | null;
+  applied_generation: number;
+  autoscaler: ComputeAutoscalerState$Outbound;
+  desired: ComputeScalingInput$Outbound;
+  desired_generation: number;
+  desired_updated_at: string;
+  replicas: ComputeScalingReplicas$Outbound;
+};
+
+/** @internal */
+export const ComputeServiceScaling$outboundSchema: z.ZodType<
+  ComputeServiceScaling$Outbound,
+  z.ZodTypeDef,
+  ComputeServiceScaling
+> = z.object({
+  applied: z.nullable(ComputeScalingInput$outboundSchema),
+  appliedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  appliedGeneration: z.number().int(),
+  autoscaler: ComputeAutoscalerState$outboundSchema,
+  desired: ComputeScalingInput$outboundSchema,
+  desiredGeneration: z.number().int(),
+  desiredUpdatedAt: z.date().transform(v => v.toISOString()),
+  replicas: ComputeScalingReplicas$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    appliedAt: "applied_at",
+    appliedGeneration: "applied_generation",
+    desiredGeneration: "desired_generation",
+    desiredUpdatedAt: "desired_updated_at",
+  });
+});
+
+export function computeServiceScalingToJSON(
+  computeServiceScaling: ComputeServiceScaling,
+): string {
+  return JSON.stringify(
+    ComputeServiceScaling$outboundSchema.parse(computeServiceScaling),
+  );
+}
+export function computeServiceScalingFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeServiceScaling, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeServiceScaling$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeServiceScaling' from JSON`,
+  );
+}

package/src/models/components/computetenant.ts

@@ -12,6 +12,7 @@ export type ComputeTenant = {
   createdAt: Date;
   enabled: boolean;
   maxLiveJobs: number | null;
+  maxLiveServiceReplicas: number | null;
   maxLiveServices: number | null;
   maxLiveVolumes: number | null;
   orgId: string;
@@ -27,6 +28,7 @@ export const ComputeTenant$inboundSchema: z.ZodType<
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
   enabled: z.boolean(),
   max_live_jobs: z.nullable(z.number().int()),
+  max_live_service_replicas: z.nullable(z.number().int()),
   max_live_services: z.nullable(z.number().int()),
   max_live_volumes: z.nullable(z.number().int()),
   org_id: z.string(),
@@ -35,6 +37,7 @@ export const ComputeTenant$inboundSchema: z.ZodType<
   return remap$(v, {
     "created_at": "createdAt",
     "max_live_jobs": "maxLiveJobs",
+    "max_live_service_replicas": "maxLiveServiceReplicas",
     "max_live_services": "maxLiveServices",
     "max_live_volumes": "maxLiveVolumes",
     "org_id": "orgId",
@@ -46,6 +49,7 @@ export type ComputeTenant$Outbound = {
   created_at: string;
   enabled: boolean;
   max_live_jobs: number | null;
+  max_live_service_replicas: number | null;
   max_live_services: number | null;
   max_live_volumes: number | null;
   org_id: string;
@@ -61,6 +65,7 @@ export const ComputeTenant$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()),
   enabled: z.boolean(),
   maxLiveJobs: z.nullable(z.number().int()),
+  maxLiveServiceReplicas: z.nullable(z.number().int()),
   maxLiveServices: z.nullable(z.number().int()),
   maxLiveVolumes: z.nullable(z.number().int()),
   orgId: z.string(),
@@ -69,6 +74,7 @@ export const ComputeTenant$outboundSchema: z.ZodType<
   return remap$(v, {
     createdAt: "created_at",
     maxLiveJobs: "max_live_jobs",
+    maxLiveServiceReplicas: "max_live_service_replicas",
     maxLiveServices: "max_live_services",
     maxLiveVolumes: "max_live_volumes",
     orgId: "org_id",

package/src/models/components/computetenantupdate.ts

@@ -11,6 +11,7 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 export type ComputeTenantUpdate = {
   enabled?: boolean | undefined;
   maxLiveJobs?: number | null | undefined;
+  maxLiveServiceReplicas?: number | null | undefined;
   maxLiveServices?: number | null | undefined;
   maxLiveVolumes?: number | null | undefined;
 };
@@ -23,11 +24,13 @@ export const ComputeTenantUpdate$inboundSchema: z.ZodType<
 > = z.object({
   enabled: z.boolean().optional(),
   max_live_jobs: z.nullable(z.number().int()).optional(),
+  max_live_service_replicas: z.nullable(z.number().int()).optional(),
   max_live_services: z.nullable(z.number().int()).optional(),
   max_live_volumes: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "max_live_jobs": "maxLiveJobs",
+    "max_live_service_replicas": "maxLiveServiceReplicas",
     "max_live_services": "maxLiveServices",
     "max_live_volumes": "maxLiveVolumes",
   });
@@ -36,6 +39,7 @@ export const ComputeTenantUpdate$inboundSchema: z.ZodType<
 export type ComputeTenantUpdate$Outbound = {
   enabled?: boolean | undefined;
   max_live_jobs?: number | null | undefined;
+  max_live_service_replicas?: number | null | undefined;
   max_live_services?: number | null | undefined;
   max_live_volumes?: number | null | undefined;
 };
@@ -48,11 +52,13 @@ export const ComputeTenantUpdate$outboundSchema: z.ZodType<
 > = z.object({
   enabled: z.boolean().optional(),
   maxLiveJobs: z.nullable(z.number().int()).optional(),
+  maxLiveServiceReplicas: z.nullable(z.number().int()).optional(),
   maxLiveServices: z.nullable(z.number().int()).optional(),
   maxLiveVolumes: z.nullable(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
     maxLiveJobs: "max_live_jobs",
+    maxLiveServiceReplicas: "max_live_service_replicas",
     maxLiveServices: "max_live_services",
     maxLiveVolumes: "max_live_volumes",
   });

package/src/models/components/computeusage.ts

@@ -24,6 +24,10 @@ export type ComputeUsageData = {
   billableSeconds: number;
   costBreakdownUsd?: CostBreakdownUsd | undefined;
   name: string;
+  /**
+   * Summed per-incarnation compute seconds; present for service rows.
+   */
+  replicaSeconds?: number | undefined;
   resourceId: string;
   resourceType: ComputeUsageResourceType;
   storedByteSeconds?: number | undefined;
@@ -157,6 +161,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
   billable_seconds: z.number(),
   cost_breakdown_usd: z.lazy(() => CostBreakdownUsd$inboundSchema).optional(),
   name: z.string(),
+  replica_seconds: z.number().optional(),
   resource_id: z.string(),
   resource_type: ComputeUsageResourceType$inboundSchema,
   stored_byte_seconds: z.number().optional(),
@@ -166,6 +171,7 @@ export const ComputeUsageData$inboundSchema: z.ZodType<
     "accrued_usd": "accruedUsd",
     "billable_seconds": "billableSeconds",
     "cost_breakdown_usd": "costBreakdownUsd",
+    "replica_seconds": "replicaSeconds",
     "resource_id": "resourceId",
     "resource_type": "resourceType",
     "stored_byte_seconds": "storedByteSeconds",
@@ -178,6 +184,7 @@ export type ComputeUsageData$Outbound = {
   billable_seconds: number;
   cost_breakdown_usd?: CostBreakdownUsd$Outbound | undefined;
   name: string;
+  replica_seconds?: number | undefined;
   resource_id: string;
   resource_type: string;
   stored_byte_seconds?: number | undefined;
@@ -194,6 +201,7 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
   billableSeconds: z.number(),
   costBreakdownUsd: z.lazy(() => CostBreakdownUsd$outboundSchema).optional(),
   name: z.string(),
+  replicaSeconds: z.number().optional(),
   resourceId: z.string(),
   resourceType: ComputeUsageResourceType$outboundSchema,
   storedByteSeconds: z.number().optional(),
@@ -203,6 +211,7 @@ export const ComputeUsageData$outboundSchema: z.ZodType<
     accruedUsd: "accrued_usd",
     billableSeconds: "billable_seconds",
     costBreakdownUsd: "cost_breakdown_usd",
+    replicaSeconds: "replica_seconds",
     resourceId: "resource_id",
     resourceType: "resource_type",
     storedByteSeconds: "stored_byte_seconds",

package/src/models/components/index.ts

@@ -83,6 +83,7 @@ export * from "./compoundfilter.js";
 export * from "./computeaccelerator.js";
 export * from "./computeacceleratorlist.js";
 export * from "./computeaccesscreate.js";
+export * from "./computeautoscalerstate.js";
 export * from "./computecontainercreate.js";
 export * from "./computeendpoint.js";
 export * from "./computeerror.js";
@@ -117,6 +118,7 @@ export * from "./computequoterequest.js";
 export * from "./computeraction.js";
 export * from "./computereadiness.js";
 export * from "./computereason.js";
+export * from "./computeregistrycredential.js";
 export * from "./computerequest.js";
 export * from "./computeresourcecreate.js";
 export * from "./computeresourcestate.js";
@@ -128,6 +130,7 @@ export * from "./computertoolcalloutputwithid.js";
 export * from "./computertoolcallwithid.js";
 export * from "./computerusetooldefinition.js";
 export * from "./computescalinginput.js";
+export * from "./computescalingreplicas.js";
 export * from "./computesecret.js";
 export * from "./computesecretcreate.js";
 export * from "./computesecretlist.js";
@@ -135,6 +138,7 @@ export * from "./computesecretreference.js";
 export * from "./computeservice.js";
 export * from "./computeserviceinput.js";
 export * from "./computeservicelist.js";
+export * from "./computeservicescaling.js";
 export * from "./computessh.js";
 export * from "./computestandalonevolume.js";
 export * from "./computestandalonevolumeattachment.js";

package/src/models/components/updatecatalogmodelrequest.ts

@@ -6,6 +6,7 @@ import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import { RFCDate } from "../../types/rfcdate.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   AutoEndpoint,
@@ -298,6 +299,12 @@ export type UpdateCatalogModelRequestHealthCheck =
   | UpdateCatalogModelRequestHealthCheck2
   | UpdateCatalogModelRequestHealthCheck3;
 
+export type UpdateCatalogModelRequestModelCard = {
+  parameterCount?: number | undefined;
+  activeParameterCount?: number | undefined;
+  releaseDate?: RFCDate | undefined;
+};
+
 export type UpdateCatalogModelRequest = {
   provider?: string | undefined;
   modelId?: string | undefined;
@@ -332,6 +339,7 @@ export type UpdateCatalogModelRequest = {
     | UpdateCatalogModelRequestHealthCheck3
     | null
     | undefined;
+  modelCard?: UpdateCatalogModelRequestModelCard | null | undefined;
   id: string;
 };
 
@@ -2209,6 +2217,54 @@ export function updateCatalogModelRequestHealthCheckFromJSON(
   );
 }
 
+/** @internal */
+export const UpdateCatalogModelRequestModelCard$inboundSchema: z.ZodType<
+  UpdateCatalogModelRequestModelCard,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  parameterCount: z.number().int().optional(),
+  activeParameterCount: z.number().int().optional(),
+  releaseDate: z.string().transform(v => new RFCDate(v)).optional(),
+});
+/** @internal */
+export type UpdateCatalogModelRequestModelCard$Outbound = {
+  parameterCount?: number | undefined;
+  activeParameterCount?: number | undefined;
+  releaseDate?: string | undefined;
+};
+
+/** @internal */
+export const UpdateCatalogModelRequestModelCard$outboundSchema: z.ZodType<
+  UpdateCatalogModelRequestModelCard$Outbound,
+  z.ZodTypeDef,
+  UpdateCatalogModelRequestModelCard
+> = z.object({
+  parameterCount: z.number().int().optional(),
+  activeParameterCount: z.number().int().optional(),
+  releaseDate: z.instanceof(RFCDate).transform(v => v.toString()).optional(),
+});
+
+export function updateCatalogModelRequestModelCardToJSON(
+  updateCatalogModelRequestModelCard: UpdateCatalogModelRequestModelCard,
+): string {
+  return JSON.stringify(
+    UpdateCatalogModelRequestModelCard$outboundSchema.parse(
+      updateCatalogModelRequestModelCard,
+    ),
+  );
+}
+export function updateCatalogModelRequestModelCardFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateCatalogModelRequestModelCard, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      UpdateCatalogModelRequestModelCard$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateCatalogModelRequestModelCard' from JSON`,
+  );
+}
+
 /** @internal */
 export const UpdateCatalogModelRequest$inboundSchema: z.ZodType<
   UpdateCatalogModelRequest,
@@ -2259,6 +2315,9 @@ export const UpdateCatalogModelRequest$inboundSchema: z.ZodType<
       z.lazy(() => UpdateCatalogModelRequestHealthCheck3$inboundSchema),
     ]),
   ).optional(),
+  modelCard: z.nullable(
+    z.lazy(() => UpdateCatalogModelRequestModelCard$inboundSchema),
+  ).optional(),
   id: z.string(),
 });
 /** @internal */
@@ -2308,6 +2367,7 @@ export type UpdateCatalogModelRequest$Outbound = {
     | UpdateCatalogModelRequestHealthCheck3$Outbound
     | null
     | undefined;
+  modelCard?: UpdateCatalogModelRequestModelCard$Outbound | null | undefined;
   id: string;
 };
 
@@ -2361,6 +2421,9 @@ export const UpdateCatalogModelRequest$outboundSchema: z.ZodType<
       z.lazy(() => UpdateCatalogModelRequestHealthCheck3$outboundSchema),
     ]),
   ).optional(),
+  modelCard: z.nullable(
+    z.lazy(() => UpdateCatalogModelRequestModelCard$outboundSchema),
+  ).optional(),
   id: z.string(),
 });
 

package/src/models/operations/getmodel.ts

@@ -7,6 +7,7 @@ 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 { RFCDate } from "../../types/rfcdate.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type GetModelRequest = {
@@ -57,6 +58,18 @@ export type GetModelResponseBody = {
    * Modalities this model can produce, mirroring the registry's `capabilities.modalities.output`. Unconstrained strings rather than a closed enum so a new registry modality reaches clients without a breaking schema change.
    */
   outputModalities: Array<string>;
+  /**
+   * Total parameter count of the weights behind this model, mirroring the registry's `modelCard.parameterCount`. Null when the registry does not record one (closed-weight API models, or entries nobody has filled in yet).
+   */
+  parameterCount: number | null;
+  /**
+   * Parameters active per token for mixture-of-experts models, mirroring the registry's `modelCard.activeParameterCount`. Null for dense models and whenever unrecorded.
+   */
+  activeParameterCount: number | null;
+  /**
+   * Public release date of the model as an ISO calendar date (YYYY-MM-DD), mirroring the registry's `modelCard.releaseDate`. Null when unrecorded.
+   */
+  releaseDate: RFCDate | null;
   /**
    * Curated public sampling capabilities for this model.
    */
@@ -181,6 +194,9 @@ export const GetModelResponseBody$inboundSchema: z.ZodType<
   model_type: ModelType$inboundSchema,
   input_modalities: z.array(z.string()),
   output_modalities: z.array(z.string()),
+  parameter_count: z.nullable(z.number().int()),
+  active_parameter_count: z.nullable(z.number().int()),
+  release_date: z.nullable(z.string().transform(v => new RFCDate(v))),
   capabilities: z.lazy(() => Capabilities$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
@@ -188,6 +204,9 @@ export const GetModelResponseBody$inboundSchema: z.ZodType<
     "model_type": "modelType",
     "input_modalities": "inputModalities",
     "output_modalities": "outputModalities",
+    "parameter_count": "parameterCount",
+    "active_parameter_count": "activeParameterCount",
+    "release_date": "releaseDate",
   });
 });
 /** @internal */
@@ -199,6 +218,9 @@ export type GetModelResponseBody$Outbound = {
   model_type: string;
   input_modalities: Array<string>;
   output_modalities: Array<string>;
+  parameter_count: number | null;
+  active_parameter_count: number | null;
+  release_date: string | null;
   capabilities: Capabilities$Outbound;
 };
 
@@ -215,6 +237,9 @@ export const GetModelResponseBody$outboundSchema: z.ZodType<
   modelType: ModelType$outboundSchema,
   inputModalities: z.array(z.string()),
   outputModalities: z.array(z.string()),
+  parameterCount: z.nullable(z.number().int()),
+  activeParameterCount: z.nullable(z.number().int()),
+  releaseDate: z.nullable(z.instanceof(RFCDate).transform(v => v.toString())),
   capabilities: z.lazy(() => Capabilities$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
@@ -222,6 +247,9 @@ export const GetModelResponseBody$outboundSchema: z.ZodType<
     modelType: "model_type",
     inputModalities: "input_modalities",
     outputModalities: "output_modalities",
+    parameterCount: "parameter_count",
+    activeParameterCount: "active_parameter_count",
+    releaseDate: "release_date",
   });
 });
 

package/src/models/operations/index.ts

@@ -364,6 +364,7 @@ export * from "./updateresponse.js";
 export * from "./updateresponsefeedback.js";
 export * from "./updatescopedapikey.js";
 export * from "./updateserviceaccountapikey.js";
+export * from "./updateservicescaling.js";
 export * from "./updateskill.js";
 export * from "./updateteam.js";
 export * from "./updatevectorstorefileattributes.js";