@meetkai/mka1 0.54.36 → 0.54.37

package/src/models/operations/trackingrunsdeletetag.ts

@@ -0,0 +1,168 @@
+/*
+ * 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 TrackingRunsDeleteTagRequestBody = {
+  runId: string;
+  key: string;
+};
+
+export type TrackingRunsDeleteTagRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsDeleteTagRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsDeleteTagResponseBody = {};
+
+/** @internal */
+export const TrackingRunsDeleteTagRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsDeleteTagRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+  key: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+  });
+});
+/** @internal */
+export type TrackingRunsDeleteTagRequestBody$Outbound = {
+  run_id: string;
+  key: string;
+};
+
+/** @internal */
+export const TrackingRunsDeleteTagRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsDeleteTagRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsDeleteTagRequestBody
+> = z.object({
+  runId: z.string(),
+  key: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+  });
+});
+
+export function trackingRunsDeleteTagRequestBodyToJSON(
+  trackingRunsDeleteTagRequestBody: TrackingRunsDeleteTagRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsDeleteTagRequestBody$outboundSchema.parse(
+      trackingRunsDeleteTagRequestBody,
+    ),
+  );
+}
+export function trackingRunsDeleteTagRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsDeleteTagRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsDeleteTagRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsDeleteTagRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsDeleteTagRequest$inboundSchema: z.ZodType<
+  TrackingRunsDeleteTagRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsDeleteTagRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsDeleteTagRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsDeleteTagRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsDeleteTagRequest$outboundSchema: z.ZodType<
+  TrackingRunsDeleteTagRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsDeleteTagRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsDeleteTagRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsDeleteTagRequestToJSON(
+  trackingRunsDeleteTagRequest: TrackingRunsDeleteTagRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsDeleteTagRequest$outboundSchema.parse(
+      trackingRunsDeleteTagRequest,
+    ),
+  );
+}
+export function trackingRunsDeleteTagRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsDeleteTagRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsDeleteTagRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsDeleteTagRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsDeleteTagResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsDeleteTagResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type TrackingRunsDeleteTagResponseBody$Outbound = {};
+
+/** @internal */
+export const TrackingRunsDeleteTagResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsDeleteTagResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsDeleteTagResponseBody
+> = z.object({});
+
+export function trackingRunsDeleteTagResponseBodyToJSON(
+  trackingRunsDeleteTagResponseBody: TrackingRunsDeleteTagResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsDeleteTagResponseBody$outboundSchema.parse(
+      trackingRunsDeleteTagResponseBody,
+    ),
+  );
+}
+export function trackingRunsDeleteTagResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsDeleteTagResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsDeleteTagResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsDeleteTagResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunsget.ts

@@ -0,0 +1,118 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type TrackingRunsGetRequest = {
+  runId: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsGetResponseBody = {
+  run: components.Run;
+};
+
+/** @internal */
+export const TrackingRunsGetRequest$inboundSchema: z.ZodType<
+  TrackingRunsGetRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type TrackingRunsGetRequest$Outbound = {
+  run_id: string;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsGetRequest$outboundSchema: z.ZodType<
+  TrackingRunsGetRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsGetRequest
+> = z.object({
+  runId: z.string(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function trackingRunsGetRequestToJSON(
+  trackingRunsGetRequest: TrackingRunsGetRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsGetRequest$outboundSchema.parse(trackingRunsGetRequest),
+  );
+}
+export function trackingRunsGetRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsGetRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsGetRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsGetRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsGetResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsGetResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run: components.Run$inboundSchema,
+});
+/** @internal */
+export type TrackingRunsGetResponseBody$Outbound = {
+  run: components.Run$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsGetResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsGetResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsGetResponseBody
+> = z.object({
+  run: components.Run$outboundSchema,
+});
+
+export function trackingRunsGetResponseBodyToJSON(
+  trackingRunsGetResponseBody: TrackingRunsGetResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsGetResponseBody$outboundSchema.parse(
+      trackingRunsGetResponseBody,
+    ),
+  );
+}
+export function trackingRunsGetResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsGetResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsGetResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsGetResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunsgetmetrichistory.ts

@@ -0,0 +1,158 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type TrackingRunsGetMetricHistoryRequest = {
+  runId: string;
+  metricKey: string;
+  maxResults?: number | undefined;
+  pageToken?: string | undefined;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsGetMetricHistoryResponseBody = {
+  metrics?: Array<components.Metric> | undefined;
+  nextPageToken?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsGetMetricHistoryRequest$inboundSchema: z.ZodType<
+  TrackingRunsGetMetricHistoryRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+  metric_key: z.string(),
+  max_results: z.number().int().optional(),
+  page_token: z.string().optional(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+    "metric_key": "metricKey",
+    "max_results": "maxResults",
+    "page_token": "pageToken",
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type TrackingRunsGetMetricHistoryRequest$Outbound = {
+  run_id: string;
+  metric_key: string;
+  max_results?: number | undefined;
+  page_token?: string | undefined;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsGetMetricHistoryRequest$outboundSchema: z.ZodType<
+  TrackingRunsGetMetricHistoryRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsGetMetricHistoryRequest
+> = z.object({
+  runId: z.string(),
+  metricKey: z.string(),
+  maxResults: z.number().int().optional(),
+  pageToken: z.string().optional(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+    metricKey: "metric_key",
+    maxResults: "max_results",
+    pageToken: "page_token",
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function trackingRunsGetMetricHistoryRequestToJSON(
+  trackingRunsGetMetricHistoryRequest: TrackingRunsGetMetricHistoryRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsGetMetricHistoryRequest$outboundSchema.parse(
+      trackingRunsGetMetricHistoryRequest,
+    ),
+  );
+}
+export function trackingRunsGetMetricHistoryRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsGetMetricHistoryRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TrackingRunsGetMetricHistoryRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsGetMetricHistoryRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsGetMetricHistoryResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsGetMetricHistoryResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  metrics: z.array(components.Metric$inboundSchema).optional(),
+  next_page_token: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "next_page_token": "nextPageToken",
+  });
+});
+/** @internal */
+export type TrackingRunsGetMetricHistoryResponseBody$Outbound = {
+  metrics?: Array<components.Metric$Outbound> | undefined;
+  next_page_token?: string | undefined;
+};
+
+/** @internal */
+export const TrackingRunsGetMetricHistoryResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsGetMetricHistoryResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsGetMetricHistoryResponseBody
+> = z.object({
+  metrics: z.array(components.Metric$outboundSchema).optional(),
+  nextPageToken: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    nextPageToken: "next_page_token",
+  });
+});
+
+export function trackingRunsGetMetricHistoryResponseBodyToJSON(
+  trackingRunsGetMetricHistoryResponseBody:
+    TrackingRunsGetMetricHistoryResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsGetMetricHistoryResponseBody$outboundSchema.parse(
+      trackingRunsGetMetricHistoryResponseBody,
+    ),
+  );
+}
+export function trackingRunsGetMetricHistoryResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TrackingRunsGetMetricHistoryResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TrackingRunsGetMetricHistoryResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TrackingRunsGetMetricHistoryResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunslogbatch.ts

@@ -0,0 +1,177 @@
+/*
+ * 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 * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type TrackingRunsLogBatchRequestBody = {
+  runId: string;
+  metrics?: Array<components.Metric> | undefined;
+  params?: Array<components.Param> | undefined;
+  tags?: Array<components.Tag> | undefined;
+};
+
+export type TrackingRunsLogBatchRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsLogBatchRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsLogBatchResponseBody = {};
+
+/** @internal */
+export const TrackingRunsLogBatchRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsLogBatchRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+  metrics: z.array(components.Metric$inboundSchema).optional(),
+  params: z.array(components.Param$inboundSchema).optional(),
+  tags: z.array(components.Tag$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+  });
+});
+/** @internal */
+export type TrackingRunsLogBatchRequestBody$Outbound = {
+  run_id: string;
+  metrics?: Array<components.Metric$Outbound> | undefined;
+  params?: Array<components.Param$Outbound> | undefined;
+  tags?: Array<components.Tag$Outbound> | undefined;
+};
+
+/** @internal */
+export const TrackingRunsLogBatchRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsLogBatchRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsLogBatchRequestBody
+> = z.object({
+  runId: z.string(),
+  metrics: z.array(components.Metric$outboundSchema).optional(),
+  params: z.array(components.Param$outboundSchema).optional(),
+  tags: z.array(components.Tag$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+  });
+});
+
+export function trackingRunsLogBatchRequestBodyToJSON(
+  trackingRunsLogBatchRequestBody: TrackingRunsLogBatchRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsLogBatchRequestBody$outboundSchema.parse(
+      trackingRunsLogBatchRequestBody,
+    ),
+  );
+}
+export function trackingRunsLogBatchRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsLogBatchRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsLogBatchRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsLogBatchRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsLogBatchRequest$inboundSchema: z.ZodType<
+  TrackingRunsLogBatchRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsLogBatchRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsLogBatchRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsLogBatchRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsLogBatchRequest$outboundSchema: z.ZodType<
+  TrackingRunsLogBatchRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsLogBatchRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsLogBatchRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsLogBatchRequestToJSON(
+  trackingRunsLogBatchRequest: TrackingRunsLogBatchRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsLogBatchRequest$outboundSchema.parse(
+      trackingRunsLogBatchRequest,
+    ),
+  );
+}
+export function trackingRunsLogBatchRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsLogBatchRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsLogBatchRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsLogBatchRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsLogBatchResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsLogBatchResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type TrackingRunsLogBatchResponseBody$Outbound = {};
+
+/** @internal */
+export const TrackingRunsLogBatchResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsLogBatchResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsLogBatchResponseBody
+> = z.object({});
+
+export function trackingRunsLogBatchResponseBodyToJSON(
+  trackingRunsLogBatchResponseBody: TrackingRunsLogBatchResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsLogBatchResponseBody$outboundSchema.parse(
+      trackingRunsLogBatchResponseBody,
+    ),
+  );
+}
+export function trackingRunsLogBatchResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsLogBatchResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsLogBatchResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsLogBatchResponseBody' from JSON`,
+  );
+}