@meetkai/mka1 0.51.28 → 0.51.29

package/src/models/components/computeserviceinput.ts

@@ -0,0 +1,57 @@
+/*
+ * 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 {
+  ComputeReadiness,
+  ComputeReadiness$inboundSchema,
+  ComputeReadiness$Outbound,
+  ComputeReadiness$outboundSchema,
+} from "./computereadiness.js";
+
+export type ComputeServiceInput = {
+  readiness?: ComputeReadiness | undefined;
+};
+
+/** @internal */
+export const ComputeServiceInput$inboundSchema: z.ZodType<
+  ComputeServiceInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  readiness: ComputeReadiness$inboundSchema.optional(),
+});
+/** @internal */
+export type ComputeServiceInput$Outbound = {
+  readiness?: ComputeReadiness$Outbound | undefined;
+};
+
+/** @internal */
+export const ComputeServiceInput$outboundSchema: z.ZodType<
+  ComputeServiceInput$Outbound,
+  z.ZodTypeDef,
+  ComputeServiceInput
+> = z.object({
+  readiness: ComputeReadiness$outboundSchema.optional(),
+});
+
+export function computeServiceInputToJSON(
+  computeServiceInput: ComputeServiceInput,
+): string {
+  return JSON.stringify(
+    ComputeServiceInput$outboundSchema.parse(computeServiceInput),
+  );
+}
+export function computeServiceInputFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeServiceInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeServiceInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeServiceInput' from JSON`,
+  );
+}

package/src/models/components/computeservicelist.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 {
+  ComputeService,
+  ComputeService$inboundSchema,
+  ComputeService$Outbound,
+  ComputeService$outboundSchema,
+} from "./computeservice.js";
+
+export type ComputeServiceList = {
+  nextCursor: string | null;
+  total: number;
+  data: Array<ComputeService>;
+};
+
+/** @internal */
+export const ComputeServiceList$inboundSchema: z.ZodType<
+  ComputeServiceList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  next_cursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeService$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "next_cursor": "nextCursor",
+  });
+});
+/** @internal */
+export type ComputeServiceList$Outbound = {
+  next_cursor: string | null;
+  total: number;
+  data: Array<ComputeService$Outbound>;
+};
+
+/** @internal */
+export const ComputeServiceList$outboundSchema: z.ZodType<
+  ComputeServiceList$Outbound,
+  z.ZodTypeDef,
+  ComputeServiceList
+> = z.object({
+  nextCursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeService$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    nextCursor: "next_cursor",
+  });
+});
+
+export function computeServiceListToJSON(
+  computeServiceList: ComputeServiceList,
+): string {
+  return JSON.stringify(
+    ComputeServiceList$outboundSchema.parse(computeServiceList),
+  );
+}
+export function computeServiceListFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeServiceList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeServiceList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeServiceList' from JSON`,
+  );
+}

package/src/models/components/computessh.ts

@@ -0,0 +1,59 @@
+/*
+ * 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";
+
+export type ComputeSSH = {
+  command: string;
+  host: string;
+  port: number;
+  user: string;
+};
+
+/** @internal */
+export const ComputeSSH$inboundSchema: z.ZodType<
+  ComputeSSH,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  command: z.string(),
+  host: z.string(),
+  port: z.number().int(),
+  user: z.string(),
+});
+/** @internal */
+export type ComputeSSH$Outbound = {
+  command: string;
+  host: string;
+  port: number;
+  user: string;
+};
+
+/** @internal */
+export const ComputeSSH$outboundSchema: z.ZodType<
+  ComputeSSH$Outbound,
+  z.ZodTypeDef,
+  ComputeSSH
+> = z.object({
+  command: z.string(),
+  host: z.string(),
+  port: z.number().int(),
+  user: z.string(),
+});
+
+export function computeSSHToJSON(computeSSH: ComputeSSH): string {
+  return JSON.stringify(ComputeSSH$outboundSchema.parse(computeSSH));
+}
+export function computeSSHFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeSSH, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeSSH$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeSSH' from JSON`,
+  );
+}

package/src/models/components/computetenant.ts

@@ -0,0 +1,84 @@
+/*
+ * 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 ComputeTenant = {
+  createdAt: Date;
+  enabled: boolean;
+  maxLiveJobs: number | null;
+  maxLiveServices: number | null;
+  orgId: string;
+  updatedAt: Date;
+};
+
+/** @internal */
+export const ComputeTenant$inboundSchema: z.ZodType<
+  ComputeTenant,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  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_services: z.nullable(z.number().int()),
+  org_id: z.string(),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "max_live_jobs": "maxLiveJobs",
+    "max_live_services": "maxLiveServices",
+    "org_id": "orgId",
+    "updated_at": "updatedAt",
+  });
+});
+/** @internal */
+export type ComputeTenant$Outbound = {
+  created_at: string;
+  enabled: boolean;
+  max_live_jobs: number | null;
+  max_live_services: number | null;
+  org_id: string;
+  updated_at: string;
+};
+
+/** @internal */
+export const ComputeTenant$outboundSchema: z.ZodType<
+  ComputeTenant$Outbound,
+  z.ZodTypeDef,
+  ComputeTenant
+> = z.object({
+  createdAt: z.date().transform(v => v.toISOString()),
+  enabled: z.boolean(),
+  maxLiveJobs: z.nullable(z.number().int()),
+  maxLiveServices: z.nullable(z.number().int()),
+  orgId: z.string(),
+  updatedAt: z.date().transform(v => v.toISOString()),
+}).transform((v) => {
+  return remap$(v, {
+    createdAt: "created_at",
+    maxLiveJobs: "max_live_jobs",
+    maxLiveServices: "max_live_services",
+    orgId: "org_id",
+    updatedAt: "updated_at",
+  });
+});
+
+export function computeTenantToJSON(computeTenant: ComputeTenant): string {
+  return JSON.stringify(ComputeTenant$outboundSchema.parse(computeTenant));
+}
+export function computeTenantFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeTenant, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeTenant$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeTenant' from JSON`,
+  );
+}

package/src/models/components/computetenantlist.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 {
+  ComputeTenant,
+  ComputeTenant$inboundSchema,
+  ComputeTenant$Outbound,
+  ComputeTenant$outboundSchema,
+} from "./computetenant.js";
+
+export type ComputeTenantList = {
+  nextCursor: string | null;
+  total: number;
+  data: Array<ComputeTenant>;
+};
+
+/** @internal */
+export const ComputeTenantList$inboundSchema: z.ZodType<
+  ComputeTenantList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  next_cursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeTenant$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "next_cursor": "nextCursor",
+  });
+});
+/** @internal */
+export type ComputeTenantList$Outbound = {
+  next_cursor: string | null;
+  total: number;
+  data: Array<ComputeTenant$Outbound>;
+};
+
+/** @internal */
+export const ComputeTenantList$outboundSchema: z.ZodType<
+  ComputeTenantList$Outbound,
+  z.ZodTypeDef,
+  ComputeTenantList
+> = z.object({
+  nextCursor: z.nullable(z.string()),
+  total: z.number().int(),
+  data: z.array(ComputeTenant$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    nextCursor: "next_cursor",
+  });
+});
+
+export function computeTenantListToJSON(
+  computeTenantList: ComputeTenantList,
+): string {
+  return JSON.stringify(
+    ComputeTenantList$outboundSchema.parse(computeTenantList),
+  );
+}
+export function computeTenantListFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeTenantList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeTenantList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeTenantList' from JSON`,
+  );
+}

package/src/models/components/computetenantupdate.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 ComputeTenantUpdate = {
+  enabled?: boolean | undefined;
+  maxLiveJobs?: number | null | undefined;
+  maxLiveServices?: number | null | undefined;
+};
+
+/** @internal */
+export const ComputeTenantUpdate$inboundSchema: z.ZodType<
+  ComputeTenantUpdate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().optional(),
+  max_live_jobs: z.nullable(z.number().int()).optional(),
+  max_live_services: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_live_jobs": "maxLiveJobs",
+    "max_live_services": "maxLiveServices",
+  });
+});
+/** @internal */
+export type ComputeTenantUpdate$Outbound = {
+  enabled?: boolean | undefined;
+  max_live_jobs?: number | null | undefined;
+  max_live_services?: number | null | undefined;
+};
+
+/** @internal */
+export const ComputeTenantUpdate$outboundSchema: z.ZodType<
+  ComputeTenantUpdate$Outbound,
+  z.ZodTypeDef,
+  ComputeTenantUpdate
+> = z.object({
+  enabled: z.boolean().optional(),
+  maxLiveJobs: z.nullable(z.number().int()).optional(),
+  maxLiveServices: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxLiveJobs: "max_live_jobs",
+    maxLiveServices: "max_live_services",
+  });
+});
+
+export function computeTenantUpdateToJSON(
+  computeTenantUpdate: ComputeTenantUpdate,
+): string {
+  return JSON.stringify(
+    ComputeTenantUpdate$outboundSchema.parse(computeTenantUpdate),
+  );
+}
+export function computeTenantUpdateFromJSON(
+  jsonString: string,
+): SafeParseResult<ComputeTenantUpdate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ComputeTenantUpdate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ComputeTenantUpdate' from JSON`,
+  );
+}

package/src/models/components/computeusage.ts

@@ -0,0 +1,253 @@
+/*
+ * 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 ComputeUsageData = {
+  accruedUsd: number;
+  billableSeconds: number;
+  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 ComputeUsageData$inboundSchema: z.ZodType<
+  ComputeUsageData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  accrued_usd: z.number(),
+  billable_seconds: z.number().int(),
+  name: z.string(),
+  resource_id: z.string(),
+  resource_type: ComputeResourceType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "accrued_usd": "accruedUsd",
+    "billable_seconds": "billableSeconds",
+    "resource_id": "resourceId",
+    "resource_type": "resourceType",
+  });
+});
+/** @internal */
+export type ComputeUsageData$Outbound = {
+  accrued_usd: number;
+  billable_seconds: number;
+  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(),
+  name: z.string(),
+  resourceId: z.string(),
+  resourceType: ComputeResourceType$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    accruedUsd: "accrued_usd",
+    billableSeconds: "billable_seconds",
+    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`,
+  );
+}