@meetkai/mka1 0.54.35 → 0.54.37

package/src/models/operations/trackingexperimentsgetbyname.ts

@@ -0,0 +1,128 @@
+/*
+ * 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 TrackingExperimentsGetByNameRequest = {
+  experimentName: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+/**
+ * Success
+ */
+export type TrackingExperimentsGetByNameResponseBody = {
+  experiment: components.Experiment;
+};
+
+/** @internal */
+export const TrackingExperimentsGetByNameRequest$inboundSchema: z.ZodType<
+  TrackingExperimentsGetByNameRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  experiment_name: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "experiment_name": "experimentName",
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type TrackingExperimentsGetByNameRequest$Outbound = {
+  experiment_name: string;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const TrackingExperimentsGetByNameRequest$outboundSchema: z.ZodType<
+  TrackingExperimentsGetByNameRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingExperimentsGetByNameRequest
+> = z.object({
+  experimentName: z.string(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    experimentName: "experiment_name",
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function trackingExperimentsGetByNameRequestToJSON(
+  trackingExperimentsGetByNameRequest: TrackingExperimentsGetByNameRequest,
+): string {
+  return JSON.stringify(
+    TrackingExperimentsGetByNameRequest$outboundSchema.parse(
+      trackingExperimentsGetByNameRequest,
+    ),
+  );
+}
+export function trackingExperimentsGetByNameRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingExperimentsGetByNameRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TrackingExperimentsGetByNameRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingExperimentsGetByNameRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingExperimentsGetByNameResponseBody$inboundSchema: z.ZodType<
+  TrackingExperimentsGetByNameResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  experiment: components.Experiment$inboundSchema,
+});
+/** @internal */
+export type TrackingExperimentsGetByNameResponseBody$Outbound = {
+  experiment: components.Experiment$Outbound;
+};
+
+/** @internal */
+export const TrackingExperimentsGetByNameResponseBody$outboundSchema: z.ZodType<
+  TrackingExperimentsGetByNameResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingExperimentsGetByNameResponseBody
+> = z.object({
+  experiment: components.Experiment$outboundSchema,
+});
+
+export function trackingExperimentsGetByNameResponseBodyToJSON(
+  trackingExperimentsGetByNameResponseBody:
+    TrackingExperimentsGetByNameResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingExperimentsGetByNameResponseBody$outboundSchema.parse(
+      trackingExperimentsGetByNameResponseBody,
+    ),
+  );
+}
+export function trackingExperimentsGetByNameResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  TrackingExperimentsGetByNameResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TrackingExperimentsGetByNameResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'TrackingExperimentsGetByNameResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingexperimentssearch.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 ViewType = {
+  ActiveOnly: "ACTIVE_ONLY",
+  DeletedOnly: "DELETED_ONLY",
+  All: "ALL",
+} as const;
+export type ViewType = ClosedEnum<typeof ViewType>;
+
+export type TrackingExperimentsSearchRequestBody = {
+  maxResults?: number | undefined;
+  filter?: string | undefined;
+  orderBy?: Array<string> | undefined;
+  pageToken?: string | undefined;
+  viewType?: ViewType | undefined;
+};
+
+export type TrackingExperimentsSearchRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingExperimentsSearchRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingExperimentsSearchResponseBody = {
+  experiments?: Array<components.Experiment> | undefined;
+  nextPageToken?: string | undefined;
+};
+
+/** @internal */
+export const ViewType$inboundSchema: z.ZodNativeEnum<typeof ViewType> = z
+  .nativeEnum(ViewType);
+/** @internal */
+export const ViewType$outboundSchema: z.ZodNativeEnum<typeof ViewType> =
+  ViewType$inboundSchema;
+
+/** @internal */
+export const TrackingExperimentsSearchRequestBody$inboundSchema: z.ZodType<
+  TrackingExperimentsSearchRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  max_results: z.number().int().optional(),
+  filter: z.string().optional(),
+  order_by: z.array(z.string()).optional(),
+  page_token: z.string().optional(),
+  view_type: ViewType$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_results": "maxResults",
+    "order_by": "orderBy",
+    "page_token": "pageToken",
+    "view_type": "viewType",
+  });
+});
+/** @internal */
+export type TrackingExperimentsSearchRequestBody$Outbound = {
+  max_results?: number | undefined;
+  filter?: string | undefined;
+  order_by?: Array<string> | undefined;
+  page_token?: string | undefined;
+  view_type?: string | undefined;
+};
+
+/** @internal */
+export const TrackingExperimentsSearchRequestBody$outboundSchema: z.ZodType<
+  TrackingExperimentsSearchRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingExperimentsSearchRequestBody
+> = z.object({
+  maxResults: z.number().int().optional(),
+  filter: z.string().optional(),
+  orderBy: z.array(z.string()).optional(),
+  pageToken: z.string().optional(),
+  viewType: ViewType$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    maxResults: "max_results",
+    orderBy: "order_by",
+    pageToken: "page_token",
+    viewType: "view_type",
+  });
+});
+
+export function trackingExperimentsSearchRequestBodyToJSON(
+  trackingExperimentsSearchRequestBody: TrackingExperimentsSearchRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingExperimentsSearchRequestBody$outboundSchema.parse(
+      trackingExperimentsSearchRequestBody,
+    ),
+  );
+}
+export function trackingExperimentsSearchRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingExperimentsSearchRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TrackingExperimentsSearchRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingExperimentsSearchRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingExperimentsSearchRequest$inboundSchema: z.ZodType<
+  TrackingExperimentsSearchRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingExperimentsSearchRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingExperimentsSearchRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingExperimentsSearchRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingExperimentsSearchRequest$outboundSchema: z.ZodType<
+  TrackingExperimentsSearchRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingExperimentsSearchRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() =>
+    TrackingExperimentsSearchRequestBody$outboundSchema
+  ),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingExperimentsSearchRequestToJSON(
+  trackingExperimentsSearchRequest: TrackingExperimentsSearchRequest,
+): string {
+  return JSON.stringify(
+    TrackingExperimentsSearchRequest$outboundSchema.parse(
+      trackingExperimentsSearchRequest,
+    ),
+  );
+}
+export function trackingExperimentsSearchRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingExperimentsSearchRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingExperimentsSearchRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingExperimentsSearchRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingExperimentsSearchResponseBody$inboundSchema: z.ZodType<
+  TrackingExperimentsSearchResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  experiments: z.array(components.Experiment$inboundSchema).optional(),
+  next_page_token: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "next_page_token": "nextPageToken",
+  });
+});
+/** @internal */
+export type TrackingExperimentsSearchResponseBody$Outbound = {
+  experiments?: Array<components.Experiment$Outbound> | undefined;
+  next_page_token?: string | undefined;
+};
+
+/** @internal */
+export const TrackingExperimentsSearchResponseBody$outboundSchema: z.ZodType<
+  TrackingExperimentsSearchResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingExperimentsSearchResponseBody
+> = z.object({
+  experiments: z.array(components.Experiment$outboundSchema).optional(),
+  nextPageToken: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    nextPageToken: "next_page_token",
+  });
+});
+
+export function trackingExperimentsSearchResponseBodyToJSON(
+  trackingExperimentsSearchResponseBody: TrackingExperimentsSearchResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingExperimentsSearchResponseBody$outboundSchema.parse(
+      trackingExperimentsSearchResponseBody,
+    ),
+  );
+}
+export function trackingExperimentsSearchResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingExperimentsSearchResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      TrackingExperimentsSearchResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingExperimentsSearchResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunscreate.ts

@@ -0,0 +1,187 @@
+/*
+ * 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 TrackingRunsCreateRequestBody = {
+  experimentId: string;
+  startTime?: number | undefined;
+  runName?: string | undefined;
+  tags?: Array<components.Tag> | undefined;
+};
+
+export type TrackingRunsCreateRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsCreateRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsCreateResponseBody = {
+  run: components.Run;
+};
+
+/** @internal */
+export const TrackingRunsCreateRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsCreateRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  experiment_id: z.string(),
+  start_time: z.number().int().optional(),
+  run_name: z.string().optional(),
+  tags: z.array(components.Tag$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "experiment_id": "experimentId",
+    "start_time": "startTime",
+    "run_name": "runName",
+  });
+});
+/** @internal */
+export type TrackingRunsCreateRequestBody$Outbound = {
+  experiment_id: string;
+  start_time?: number | undefined;
+  run_name?: string | undefined;
+  tags?: Array<components.Tag$Outbound> | undefined;
+};
+
+/** @internal */
+export const TrackingRunsCreateRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsCreateRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsCreateRequestBody
+> = z.object({
+  experimentId: z.string(),
+  startTime: z.number().int().optional(),
+  runName: z.string().optional(),
+  tags: z.array(components.Tag$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    experimentId: "experiment_id",
+    startTime: "start_time",
+    runName: "run_name",
+  });
+});
+
+export function trackingRunsCreateRequestBodyToJSON(
+  trackingRunsCreateRequestBody: TrackingRunsCreateRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsCreateRequestBody$outboundSchema.parse(
+      trackingRunsCreateRequestBody,
+    ),
+  );
+}
+export function trackingRunsCreateRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsCreateRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsCreateRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsCreateRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsCreateRequest$inboundSchema: z.ZodType<
+  TrackingRunsCreateRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsCreateRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsCreateRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsCreateRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsCreateRequest$outboundSchema: z.ZodType<
+  TrackingRunsCreateRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsCreateRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsCreateRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsCreateRequestToJSON(
+  trackingRunsCreateRequest: TrackingRunsCreateRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsCreateRequest$outboundSchema.parse(trackingRunsCreateRequest),
+  );
+}
+export function trackingRunsCreateRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsCreateRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsCreateRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsCreateRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsCreateResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsCreateResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run: components.Run$inboundSchema,
+});
+/** @internal */
+export type TrackingRunsCreateResponseBody$Outbound = {
+  run: components.Run$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsCreateResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsCreateResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsCreateResponseBody
+> = z.object({
+  run: components.Run$outboundSchema,
+});
+
+export function trackingRunsCreateResponseBodyToJSON(
+  trackingRunsCreateResponseBody: TrackingRunsCreateResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsCreateResponseBody$outboundSchema.parse(
+      trackingRunsCreateResponseBody,
+    ),
+  );
+}
+export function trackingRunsCreateResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsCreateResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsCreateResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsCreateResponseBody' from JSON`,
+  );
+}

package/src/models/operations/trackingrunsdelete.ts

@@ -0,0 +1,162 @@
+/*
+ * 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 TrackingRunsDeleteRequestBody = {
+  runId: string;
+};
+
+export type TrackingRunsDeleteRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: TrackingRunsDeleteRequestBody;
+};
+
+/**
+ * Success
+ */
+export type TrackingRunsDeleteResponseBody = {};
+
+/** @internal */
+export const TrackingRunsDeleteRequestBody$inboundSchema: z.ZodType<
+  TrackingRunsDeleteRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  run_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "run_id": "runId",
+  });
+});
+/** @internal */
+export type TrackingRunsDeleteRequestBody$Outbound = {
+  run_id: string;
+};
+
+/** @internal */
+export const TrackingRunsDeleteRequestBody$outboundSchema: z.ZodType<
+  TrackingRunsDeleteRequestBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsDeleteRequestBody
+> = z.object({
+  runId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    runId: "run_id",
+  });
+});
+
+export function trackingRunsDeleteRequestBodyToJSON(
+  trackingRunsDeleteRequestBody: TrackingRunsDeleteRequestBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsDeleteRequestBody$outboundSchema.parse(
+      trackingRunsDeleteRequestBody,
+    ),
+  );
+}
+export function trackingRunsDeleteRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsDeleteRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsDeleteRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsDeleteRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsDeleteRequest$inboundSchema: z.ZodType<
+  TrackingRunsDeleteRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => TrackingRunsDeleteRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type TrackingRunsDeleteRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: TrackingRunsDeleteRequestBody$Outbound;
+};
+
+/** @internal */
+export const TrackingRunsDeleteRequest$outboundSchema: z.ZodType<
+  TrackingRunsDeleteRequest$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsDeleteRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => TrackingRunsDeleteRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function trackingRunsDeleteRequestToJSON(
+  trackingRunsDeleteRequest: TrackingRunsDeleteRequest,
+): string {
+  return JSON.stringify(
+    TrackingRunsDeleteRequest$outboundSchema.parse(trackingRunsDeleteRequest),
+  );
+}
+export function trackingRunsDeleteRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsDeleteRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsDeleteRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsDeleteRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const TrackingRunsDeleteResponseBody$inboundSchema: z.ZodType<
+  TrackingRunsDeleteResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({});
+/** @internal */
+export type TrackingRunsDeleteResponseBody$Outbound = {};
+
+/** @internal */
+export const TrackingRunsDeleteResponseBody$outboundSchema: z.ZodType<
+  TrackingRunsDeleteResponseBody$Outbound,
+  z.ZodTypeDef,
+  TrackingRunsDeleteResponseBody
+> = z.object({});
+
+export function trackingRunsDeleteResponseBodyToJSON(
+  trackingRunsDeleteResponseBody: TrackingRunsDeleteResponseBody,
+): string {
+  return JSON.stringify(
+    TrackingRunsDeleteResponseBody$outboundSchema.parse(
+      trackingRunsDeleteResponseBody,
+    ),
+  );
+}
+export function trackingRunsDeleteResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<TrackingRunsDeleteResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TrackingRunsDeleteResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TrackingRunsDeleteResponseBody' from JSON`,
+  );
+}