@meetkai/mka1 0.54.36 → 0.54.38

package/src/models/operations/trackingrunssearch.ts

@@ -0,0 +1,226 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const RunViewType = {
+  ActiveOnly: "ACTIVE_ONLY",
+  DeletedOnly: "DELETED_ONLY",
+  All: "ALL",
+} as const;
+export type RunViewType = ClosedEnum<typeof RunViewType>;
+
+export type TrackingRunsSearchRequestBody = {
+  experimentIds: Array<string>;
+  filter?: string | undefined;
+  maxResults?: number | undefined;
+  orderBy?: Array<string> | undefined;
+  pageToken?: string | undefined;
+  runViewType?: RunViewType | undefined;
+};
+
+export type TrackingRunsSearchRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsSearchRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsSearchResponseBody = {
+  runs?: Array<components.Run> | undefined;
+  nextPageToken?: string | undefined;
+};
+
+/** @internal */
+export const RunViewType$inboundSchema: z.ZodNativeEnum<typeof RunViewType> = z
+  .nativeEnum(RunViewType);
+/** @internal */
+export const RunViewType$outboundSchema: z.ZodNativeEnum<typeof RunViewType> =
+  RunViewType$inboundSchema;
+
+/** @internal */
+export const TrackingRunsSearchRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsSearchRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  experiment_ids: z.array(z.string()),
+  filter: z.string().optional(),
+  max_results: z.number().int().optional(),
+  order_by: z.array(z.string()).optional(),
+  page_token: z.string().optional(),
+  run_view_type: RunViewType$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "experiment_ids": "experimentIds",
+    "max_results": "maxResults",
+    "order_by": "orderBy",
+    "page_token": "pageToken",
+    "run_view_type": "runViewType",
+  });
+});
+/** @internal */
+export type TrackingRunsSearchRequestBody$Outbound = {
+  experiment_ids: Array<string>;
+  filter?: string | undefined;
+  max_results?: number | undefined;
+  order_by?: Array<string> | undefined;
+  page_token?: string | undefined;
+  run_view_type?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsSearchRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsSearchRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsSearchRequestBody
+> = z.object({
+  experimentIds: z.array(z.string()),
+  filter: z.string().optional(),
+  maxResults: z.number().int().optional(),
+  orderBy: z.array(z.string()).optional(),
+  pageToken: z.string().optional(),
+  runViewType: RunViewType$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    experimentIds: "experiment_ids",
+    maxResults: "max_results",
+    orderBy: "order_by",
+    pageToken: "page_token",
+    runViewType: "run_view_type",
+  });
+});
+
+export function trackingRunsSearchRequestBodyToJSON(
+  trackingRunsSearchRequestBody: TrackingRunsSearchRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsSearchRequestBody$outboundSchema.parse(
+      trackingRunsSearchRequestBody,
+    ),
+  );
+}
+export function trackingRunsSearchRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsSearchRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsSearchRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsSearchRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsSearchRequest$inboundSchema: z.ZodType<
+  TrackingRunsSearchRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsSearchRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsSearchRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsSearchRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsSearchRequest$outboundSchema: z.ZodType<
+  TrackingRunsSearchRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsSearchRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsSearchRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsSearchRequestToJSON(
+  trackingRunsSearchRequest: TrackingRunsSearchRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsSearchRequest$outboundSchema.parse(trackingRunsSearchRequest),
+  );
+}
+export function trackingRunsSearchRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsSearchRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsSearchRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsSearchRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsSearchResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsSearchResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  runs: z.array(components.Run$inboundSchema).optional(),
+  next_page_token: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "next_page_token": "nextPageToken",
+  });
+});
+/** @internal */
+export type TrackingRunsSearchResponseBody$Outbound = {
+  runs?: Array<components.Run$Outbound> | undefined;
+  next_page_token?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsSearchResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsSearchResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsSearchResponseBody
+> = z.object({
+  runs: z.array(components.Run$outboundSchema).optional(),
+  nextPageToken: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    nextPageToken: "next_page_token",
+  });
+});
+
+export function trackingRunsSearchResponseBodyToJSON(
+  trackingRunsSearchResponseBody: TrackingRunsSearchResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsSearchResponseBody$outboundSchema.parse(
+      trackingRunsSearchResponseBody,
+    ),
+  );
+}
+export function trackingRunsSearchResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsSearchResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsSearchResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsSearchResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunssettag.ts

@@ -0,0 +1,170 @@
+/*
+ * 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 TrackingRunsSetTagRequestBody = {
+  runId: string;
+  key: string;
+  value: string;
+};
+
+export type TrackingRunsSetTagRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsSetTagRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsSetTagResponseBody = {};
+
+/** @internal */
+export const TrackingRunsSetTagRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsSetTagRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+  key: z.string(),
+  value: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+  });
+});
+/** @internal */
+export type TrackingRunsSetTagRequestBody$Outbound = {
+  run_id: string;
+  key: string;
+  value: string;
+};
+
+/** @internal */
+export const TrackingRunsSetTagRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsSetTagRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsSetTagRequestBody
+> = z.object({
+  runId: z.string(),
+  key: z.string(),
+  value: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+  });
+});
+
+export function trackingRunsSetTagRequestBodyToJSON(
+  trackingRunsSetTagRequestBody: TrackingRunsSetTagRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsSetTagRequestBody$outboundSchema.parse(
+      trackingRunsSetTagRequestBody,
+    ),
+  );
+}
+export function trackingRunsSetTagRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsSetTagRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsSetTagRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsSetTagRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsSetTagRequest$inboundSchema: z.ZodType<
+  TrackingRunsSetTagRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsSetTagRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsSetTagRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsSetTagRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsSetTagRequest$outboundSchema: z.ZodType<
+  TrackingRunsSetTagRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsSetTagRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsSetTagRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsSetTagRequestToJSON(
+  trackingRunsSetTagRequest: TrackingRunsSetTagRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsSetTagRequest$outboundSchema.parse(trackingRunsSetTagRequest),
+  );
+}
+export function trackingRunsSetTagRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsSetTagRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsSetTagRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsSetTagRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsSetTagResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsSetTagResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type TrackingRunsSetTagResponseBody$Outbound = {};
+
+/** @internal */
+export const TrackingRunsSetTagResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsSetTagResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsSetTagResponseBody
+> = z.object({});
+
+export function trackingRunsSetTagResponseBodyToJSON(
+  trackingRunsSetTagResponseBody: TrackingRunsSetTagResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsSetTagResponseBody$outboundSchema.parse(
+      trackingRunsSetTagResponseBody,
+    ),
+  );
+}
+export function trackingRunsSetTagResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsSetTagResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsSetTagResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsSetTagResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunsupdate.ts

@@ -0,0 +1,212 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const Status = {
+  Running: "RUNNING",
+  Scheduled: "SCHEDULED",
+  Finished: "FINISHED",
+  Failed: "FAILED",
+  Killed: "KILLED",
+} as const;
+export type Status = ClosedEnum<typeof Status>;
+
+export type TrackingRunsUpdateRequestBody = {
+  runId: string;
+  status?: Status | undefined;
+  endTime?: number | undefined;
+  runName?: string | undefined;
+};
+
+export type TrackingRunsUpdateRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsUpdateRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsUpdateResponseBody = {
+  runInfo?: components.RunInfo | undefined;
+};
+
+/** @internal */
+export const Status$inboundSchema: z.ZodNativeEnum<typeof Status> = z
+  .nativeEnum(Status);
+/** @internal */
+export const Status$outboundSchema: z.ZodNativeEnum<typeof Status> =
+  Status$inboundSchema;
+
+/** @internal */
+export const TrackingRunsUpdateRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsUpdateRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+  status: Status$inboundSchema.optional(),
+  end_time: z.number().int().optional(),
+  run_name: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+    "end_time": "endTime",
+    "run_name": "runName",
+  });
+});
+/** @internal */
+export type TrackingRunsUpdateRequestBody$Outbound = {
+  run_id: string;
+  status?: string | undefined;
+  end_time?: number | undefined;
+  run_name?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsUpdateRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsUpdateRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsUpdateRequestBody
+> = z.object({
+  runId: z.string(),
+  status: Status$outboundSchema.optional(),
+  endTime: z.number().int().optional(),
+  runName: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+    endTime: "end_time",
+    runName: "run_name",
+  });
+});
+
+export function trackingRunsUpdateRequestBodyToJSON(
+  trackingRunsUpdateRequestBody: TrackingRunsUpdateRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsUpdateRequestBody$outboundSchema.parse(
+      trackingRunsUpdateRequestBody,
+    ),
+  );
+}
+export function trackingRunsUpdateRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsUpdateRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsUpdateRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsUpdateRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsUpdateRequest$inboundSchema: z.ZodType<
+  TrackingRunsUpdateRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsUpdateRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsUpdateRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsUpdateRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsUpdateRequest$outboundSchema: z.ZodType<
+  TrackingRunsUpdateRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsUpdateRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsUpdateRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsUpdateRequestToJSON(
+  trackingRunsUpdateRequest: TrackingRunsUpdateRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsUpdateRequest$outboundSchema.parse(trackingRunsUpdateRequest),
+  );
+}
+export function trackingRunsUpdateRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsUpdateRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsUpdateRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsUpdateRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsUpdateResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsUpdateResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_info: components.RunInfo$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_info": "runInfo",
+  });
+});
+/** @internal */
+export type TrackingRunsUpdateResponseBody$Outbound = {
+  run_info?: components.RunInfo$Outbound | undefined;
+};
+
+/** @internal */
+export const TrackingRunsUpdateResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsUpdateResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsUpdateResponseBody
+> = z.object({
+  runInfo: components.RunInfo$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    runInfo: "run_info",
+  });
+});
+
+export function trackingRunsUpdateResponseBodyToJSON(
+  trackingRunsUpdateResponseBody: TrackingRunsUpdateResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsUpdateResponseBody$outboundSchema.parse(
+      trackingRunsUpdateResponseBody,
+    ),
+  );
+}
+export function trackingRunsUpdateResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsUpdateResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsUpdateResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsUpdateResponseBody' from JSON`,
+  );
+}