/*
 * 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 types from "../types/primitives.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

/**
 * The current status of the check
 */
export const UpdateCheckStatus = {
  Running: "running",
  Completed: "completed",
} as const;
/**
 * The current status of the check
 */
export type UpdateCheckStatus = ClosedEnum<typeof UpdateCheckStatus>;

/**
 * The result of the check being run
 */
export const UpdateCheckConclusion = {
  Canceled: "canceled",
  Failed: "failed",
  Neutral: "neutral",
  Succeeded: "succeeded",
  Skipped: "skipped",
} as const;
/**
 * The result of the check being run
 */
export type UpdateCheckConclusion = ClosedEnum<typeof UpdateCheckConclusion>;

export const UpdateCheckSource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckSource = ClosedEnum<typeof UpdateCheckSource>;

export type Fcp = {
  /**
   * First Contentful Paint value
   */
  value: number | null;
  /**
   * Previous First Contentful Paint value to display a delta
   */
  previousValue?: number | undefined;
  source: UpdateCheckSource;
};

export const UpdateCheckChecksSource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksSource = ClosedEnum<
  typeof UpdateCheckChecksSource
>;

export type Lcp = {
  /**
   * Largest Contentful Paint value
   */
  value: number | null;
  /**
   * Previous Largest Contentful Paint value to display a delta
   */
  previousValue?: number | undefined;
  source: UpdateCheckChecksSource;
};

export const UpdateCheckChecksRequestSource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksRequestSource = ClosedEnum<
  typeof UpdateCheckChecksRequestSource
>;

export type Cls = {
  /**
   * Cumulative Layout Shift value
   */
  value: number | null;
  /**
   * Previous Cumulative Layout Shift value to display a delta
   */
  previousValue?: number | undefined;
  source: UpdateCheckChecksRequestSource;
};

export const UpdateCheckChecksRequestRequestBodySource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksRequestRequestBodySource = ClosedEnum<
  typeof UpdateCheckChecksRequestRequestBodySource
>;

export type Tbt = {
  /**
   * Total Blocking Time value
   */
  value: number | null;
  /**
   * Previous Total Blocking Time value to display a delta
   */
  previousValue?: number | undefined;
  source: UpdateCheckChecksRequestRequestBodySource;
};

export const UpdateCheckChecksRequestRequestBodyOutputSource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksRequestRequestBodyOutputSource = ClosedEnum<
  typeof UpdateCheckChecksRequestRequestBodyOutputSource
>;

export type VirtualExperienceScore = {
  /**
   * The calculated Virtual Experience Score value, between 0 and 100
   */
  value: number | null;
  /**
   * A previous Virtual Experience Score value to display a delta, between 0 and 100
   */
  previousValue?: number | undefined;
  source: UpdateCheckChecksRequestRequestBodyOutputSource;
};

/**
 * Metrics about the page
 */
export type Metrics = {
  fcp: Fcp;
  lcp: Lcp;
  cls: Cls;
  tbt: Tbt;
  virtualExperienceScore?: VirtualExperienceScore | undefined;
};

/**
 * The results of the check Run
 */
export type UpdateCheckOutput = {
  /**
   * Metrics about the page
   */
  metrics?: Metrics | undefined;
};

export type UpdateCheckRequestBody = {
  /**
   * The name of the check being created
   */
  name?: string | undefined;
  /**
   * Path of the page that is being checked
   */
  path?: string | undefined;
  /**
   * The current status of the check
   */
  status?: UpdateCheckStatus | undefined;
  /**
   * The result of the check being run
   */
  conclusion?: UpdateCheckConclusion | undefined;
  /**
   * A URL a user may visit to see more information about the check
   */
  detailsUrl?: string | undefined;
  /**
   * The results of the check Run
   */
  output?: UpdateCheckOutput | undefined;
  /**
   * An identifier that can be used as an external reference
   */
  externalId?: string | undefined;
};

export type UpdateCheckRequest = {
  /**
   * The deployment to update the check for.
   */
  deploymentId: string;
  /**
   * The check being updated
   */
  checkId: string;
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
  requestBody: UpdateCheckRequestBody;
};

export const UpdateCheckChecksStatus = {
  Completed: "completed",
  Registered: "registered",
  Running: "running",
} as const;
export type UpdateCheckChecksStatus = ClosedEnum<
  typeof UpdateCheckChecksStatus
>;

export const UpdateCheckChecksConclusion = {
  Canceled: "canceled",
  Failed: "failed",
  Neutral: "neutral",
  Skipped: "skipped",
  Stale: "stale",
  Succeeded: "succeeded",
} as const;
export type UpdateCheckChecksConclusion = ClosedEnum<
  typeof UpdateCheckChecksConclusion
>;

export const UpdateCheckChecksResponseSource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksResponseSource = ClosedEnum<
  typeof UpdateCheckChecksResponseSource
>;

export type UpdateCheckFCP = {
  value: number | null;
  previousValue?: number | undefined;
  source: UpdateCheckChecksResponseSource;
};

export const UpdateCheckChecksResponse200Source = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksResponse200Source = ClosedEnum<
  typeof UpdateCheckChecksResponse200Source
>;

export type UpdateCheckLCP = {
  value: number | null;
  previousValue?: number | undefined;
  source: UpdateCheckChecksResponse200Source;
};

export const UpdateCheckChecksResponse200ApplicationJSONSource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksResponse200ApplicationJSONSource = ClosedEnum<
  typeof UpdateCheckChecksResponse200ApplicationJSONSource
>;

export type UpdateCheckCLS = {
  value: number | null;
  previousValue?: number | undefined;
  source: UpdateCheckChecksResponse200ApplicationJSONSource;
};

export const UpdateCheckChecksResponse200ApplicationJSONResponseBodySource = {
  WebVitals: "web-vitals",
} as const;
export type UpdateCheckChecksResponse200ApplicationJSONResponseBodySource =
  ClosedEnum<
    typeof UpdateCheckChecksResponse200ApplicationJSONResponseBodySource
  >;

export type UpdateCheckTBT = {
  value: number | null;
  previousValue?: number | undefined;
  source: UpdateCheckChecksResponse200ApplicationJSONResponseBodySource;
};

export const UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource =
  {
    WebVitals: "web-vitals",
  } as const;
export type UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource =
  ClosedEnum<
    typeof UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource
  >;

export type UpdateCheckVirtualExperienceScore = {
  value: number | null;
  previousValue?: number | undefined;
  source: UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource;
};

export type UpdateCheckMetrics = {
  fcp: UpdateCheckFCP;
  lcp: UpdateCheckLCP;
  cls: UpdateCheckCLS;
  tbt: UpdateCheckTBT;
  virtualExperienceScore?: UpdateCheckVirtualExperienceScore | undefined;
};

export type UpdateCheckChecksOutput = {
  metrics?: UpdateCheckMetrics | undefined;
};

export type UpdateCheckResponseBody = {
  id: string;
  name: string;
  createdAt: number;
  updatedAt: number;
  deploymentId: string;
  status: UpdateCheckChecksStatus;
  conclusion?: UpdateCheckChecksConclusion | undefined;
  externalId?: string | undefined;
  output?: UpdateCheckChecksOutput | undefined;
  completedAt?: number | undefined;
  path?: string | undefined;
  blocking: boolean;
  detailsUrl?: string | undefined;
  integrationId: string;
  startedAt?: number | undefined;
  rerequestable?: boolean | undefined;
};

/** @internal */
export const UpdateCheckStatus$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckStatus
> = z.nativeEnum(UpdateCheckStatus);

/** @internal */
export const UpdateCheckConclusion$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckConclusion
> = z.nativeEnum(UpdateCheckConclusion);

/** @internal */
export const UpdateCheckSource$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckSource
> = z.nativeEnum(UpdateCheckSource);

/** @internal */
export type Fcp$Outbound = {
  value: number | null;
  previousValue?: number | undefined;
  source: string;
};

/** @internal */
export const Fcp$outboundSchema: z.ZodType<Fcp$Outbound, z.ZodTypeDef, Fcp> = z
  .object({
    value: z.nullable(z.number()),
    previousValue: z.number().optional(),
    source: UpdateCheckSource$outboundSchema,
  });

export function fcpToJSON(fcp: Fcp): string {
  return JSON.stringify(Fcp$outboundSchema.parse(fcp));
}

/** @internal */
export const UpdateCheckChecksSource$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckChecksSource
> = z.nativeEnum(UpdateCheckChecksSource);

/** @internal */
export type Lcp$Outbound = {
  value: number | null;
  previousValue?: number | undefined;
  source: string;
};

/** @internal */
export const Lcp$outboundSchema: z.ZodType<Lcp$Outbound, z.ZodTypeDef, Lcp> = z
  .object({
    value: z.nullable(z.number()),
    previousValue: z.number().optional(),
    source: UpdateCheckChecksSource$outboundSchema,
  });

export function lcpToJSON(lcp: Lcp): string {
  return JSON.stringify(Lcp$outboundSchema.parse(lcp));
}

/** @internal */
export const UpdateCheckChecksRequestSource$outboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckChecksRequestSource
> = z.nativeEnum(UpdateCheckChecksRequestSource);

/** @internal */
export type Cls$Outbound = {
  value: number | null;
  previousValue?: number | undefined;
  source: string;
};

/** @internal */
export const Cls$outboundSchema: z.ZodType<Cls$Outbound, z.ZodTypeDef, Cls> = z
  .object({
    value: z.nullable(z.number()),
    previousValue: z.number().optional(),
    source: UpdateCheckChecksRequestSource$outboundSchema,
  });

export function clsToJSON(cls: Cls): string {
  return JSON.stringify(Cls$outboundSchema.parse(cls));
}

/** @internal */
export const UpdateCheckChecksRequestRequestBodySource$outboundSchema:
  z.ZodNativeEnum<typeof UpdateCheckChecksRequestRequestBodySource> = z
    .nativeEnum(UpdateCheckChecksRequestRequestBodySource);

/** @internal */
export type Tbt$Outbound = {
  value: number | null;
  previousValue?: number | undefined;
  source: string;
};

/** @internal */
export const Tbt$outboundSchema: z.ZodType<Tbt$Outbound, z.ZodTypeDef, Tbt> = z
  .object({
    value: z.nullable(z.number()),
    previousValue: z.number().optional(),
    source: UpdateCheckChecksRequestRequestBodySource$outboundSchema,
  });

export function tbtToJSON(tbt: Tbt): string {
  return JSON.stringify(Tbt$outboundSchema.parse(tbt));
}

/** @internal */
export const UpdateCheckChecksRequestRequestBodyOutputSource$outboundSchema:
  z.ZodNativeEnum<typeof UpdateCheckChecksRequestRequestBodyOutputSource> = z
    .nativeEnum(UpdateCheckChecksRequestRequestBodyOutputSource);

/** @internal */
export type VirtualExperienceScore$Outbound = {
  value: number | null;
  previousValue?: number | undefined;
  source: string;
};

/** @internal */
export const VirtualExperienceScore$outboundSchema: z.ZodType<
  VirtualExperienceScore$Outbound,
  z.ZodTypeDef,
  VirtualExperienceScore
> = z.object({
  value: z.nullable(z.number().int()),
  previousValue: z.number().int().optional(),
  source: UpdateCheckChecksRequestRequestBodyOutputSource$outboundSchema,
});

export function virtualExperienceScoreToJSON(
  virtualExperienceScore: VirtualExperienceScore,
): string {
  return JSON.stringify(
    VirtualExperienceScore$outboundSchema.parse(virtualExperienceScore),
  );
}

/** @internal */
export type Metrics$Outbound = {
  FCP: Fcp$Outbound;
  LCP: Lcp$Outbound;
  CLS: Cls$Outbound;
  TBT: Tbt$Outbound;
  virtualExperienceScore?: VirtualExperienceScore$Outbound | undefined;
};

/** @internal */
export const Metrics$outboundSchema: z.ZodType<
  Metrics$Outbound,
  z.ZodTypeDef,
  Metrics
> = z.object({
  fcp: z.lazy(() => Fcp$outboundSchema),
  lcp: z.lazy(() => Lcp$outboundSchema),
  cls: z.lazy(() => Cls$outboundSchema),
  tbt: z.lazy(() => Tbt$outboundSchema),
  virtualExperienceScore: z.lazy(() => VirtualExperienceScore$outboundSchema)
    .optional(),
}).transform((v) => {
  return remap$(v, {
    fcp: "FCP",
    lcp: "LCP",
    cls: "CLS",
    tbt: "TBT",
  });
});

export function metricsToJSON(metrics: Metrics): string {
  return JSON.stringify(Metrics$outboundSchema.parse(metrics));
}

/** @internal */
export type UpdateCheckOutput$Outbound = {
  metrics?: Metrics$Outbound | undefined;
};

/** @internal */
export const UpdateCheckOutput$outboundSchema: z.ZodType<
  UpdateCheckOutput$Outbound,
  z.ZodTypeDef,
  UpdateCheckOutput
> = z.object({
  metrics: z.lazy(() => Metrics$outboundSchema).optional(),
});

export function updateCheckOutputToJSON(
  updateCheckOutput: UpdateCheckOutput,
): string {
  return JSON.stringify(
    UpdateCheckOutput$outboundSchema.parse(updateCheckOutput),
  );
}

/** @internal */
export type UpdateCheckRequestBody$Outbound = {
  name?: string | undefined;
  path?: string | undefined;
  status?: string | undefined;
  conclusion?: string | undefined;
  detailsUrl?: string | undefined;
  output?: UpdateCheckOutput$Outbound | undefined;
  externalId?: string | undefined;
};

/** @internal */
export const UpdateCheckRequestBody$outboundSchema: z.ZodType<
  UpdateCheckRequestBody$Outbound,
  z.ZodTypeDef,
  UpdateCheckRequestBody
> = z.object({
  name: z.string().optional(),
  path: z.string().optional(),
  status: UpdateCheckStatus$outboundSchema.optional(),
  conclusion: UpdateCheckConclusion$outboundSchema.optional(),
  detailsUrl: z.string().optional(),
  output: z.lazy(() => UpdateCheckOutput$outboundSchema).optional(),
  externalId: z.string().optional(),
});

export function updateCheckRequestBodyToJSON(
  updateCheckRequestBody: UpdateCheckRequestBody,
): string {
  return JSON.stringify(
    UpdateCheckRequestBody$outboundSchema.parse(updateCheckRequestBody),
  );
}

/** @internal */
export type UpdateCheckRequest$Outbound = {
  deploymentId: string;
  checkId: string;
  teamId?: string | undefined;
  slug?: string | undefined;
  RequestBody: UpdateCheckRequestBody$Outbound;
};

/** @internal */
export const UpdateCheckRequest$outboundSchema: z.ZodType<
  UpdateCheckRequest$Outbound,
  z.ZodTypeDef,
  UpdateCheckRequest
> = z.object({
  deploymentId: z.string(),
  checkId: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: z.lazy(() => UpdateCheckRequestBody$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function updateCheckRequestToJSON(
  updateCheckRequest: UpdateCheckRequest,
): string {
  return JSON.stringify(
    UpdateCheckRequest$outboundSchema.parse(updateCheckRequest),
  );
}

/** @internal */
export const UpdateCheckChecksStatus$inboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckChecksStatus
> = z.nativeEnum(UpdateCheckChecksStatus);

/** @internal */
export const UpdateCheckChecksConclusion$inboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckChecksConclusion
> = z.nativeEnum(UpdateCheckChecksConclusion);

/** @internal */
export const UpdateCheckChecksResponseSource$inboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckChecksResponseSource
> = z.nativeEnum(UpdateCheckChecksResponseSource);

/** @internal */
export const UpdateCheckFCP$inboundSchema: z.ZodType<
  UpdateCheckFCP,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.nullable(types.number()),
  previousValue: types.optional(types.number()),
  source: UpdateCheckChecksResponseSource$inboundSchema,
});

export function updateCheckFCPFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckFCP, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckFCP$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckFCP' from JSON`,
  );
}

/** @internal */
export const UpdateCheckChecksResponse200Source$inboundSchema: z.ZodNativeEnum<
  typeof UpdateCheckChecksResponse200Source
> = z.nativeEnum(UpdateCheckChecksResponse200Source);

/** @internal */
export const UpdateCheckLCP$inboundSchema: z.ZodType<
  UpdateCheckLCP,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.nullable(types.number()),
  previousValue: types.optional(types.number()),
  source: UpdateCheckChecksResponse200Source$inboundSchema,
});

export function updateCheckLCPFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckLCP, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckLCP$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckLCP' from JSON`,
  );
}

/** @internal */
export const UpdateCheckChecksResponse200ApplicationJSONSource$inboundSchema:
  z.ZodNativeEnum<typeof UpdateCheckChecksResponse200ApplicationJSONSource> = z
    .nativeEnum(UpdateCheckChecksResponse200ApplicationJSONSource);

/** @internal */
export const UpdateCheckCLS$inboundSchema: z.ZodType<
  UpdateCheckCLS,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.nullable(types.number()),
  previousValue: types.optional(types.number()),
  source: UpdateCheckChecksResponse200ApplicationJSONSource$inboundSchema,
});

export function updateCheckCLSFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckCLS, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckCLS$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckCLS' from JSON`,
  );
}

/** @internal */
export const UpdateCheckChecksResponse200ApplicationJSONResponseBodySource$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateCheckChecksResponse200ApplicationJSONResponseBodySource
  > = z.nativeEnum(
    UpdateCheckChecksResponse200ApplicationJSONResponseBodySource,
  );

/** @internal */
export const UpdateCheckTBT$inboundSchema: z.ZodType<
  UpdateCheckTBT,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.nullable(types.number()),
  previousValue: types.optional(types.number()),
  source:
    UpdateCheckChecksResponse200ApplicationJSONResponseBodySource$inboundSchema,
});

export function updateCheckTBTFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckTBT, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckTBT$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckTBT' from JSON`,
  );
}

/** @internal */
export const UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource$inboundSchema:
  z.ZodNativeEnum<
    typeof UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource
  > = z.nativeEnum(
    UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource,
  );

/** @internal */
export const UpdateCheckVirtualExperienceScore$inboundSchema: z.ZodType<
  UpdateCheckVirtualExperienceScore,
  z.ZodTypeDef,
  unknown
> = z.object({
  value: types.nullable(types.number()),
  previousValue: types.optional(types.number()),
  source:
    UpdateCheckChecksResponse200ApplicationJSONResponseBodyOutputSource$inboundSchema,
});

export function updateCheckVirtualExperienceScoreFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckVirtualExperienceScore, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckVirtualExperienceScore$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckVirtualExperienceScore' from JSON`,
  );
}

/** @internal */
export const UpdateCheckMetrics$inboundSchema: z.ZodType<
  UpdateCheckMetrics,
  z.ZodTypeDef,
  unknown
> = z.object({
  FCP: z.lazy(() => UpdateCheckFCP$inboundSchema),
  LCP: z.lazy(() => UpdateCheckLCP$inboundSchema),
  CLS: z.lazy(() => UpdateCheckCLS$inboundSchema),
  TBT: z.lazy(() => UpdateCheckTBT$inboundSchema),
  virtualExperienceScore: types.optional(
    z.lazy(() => UpdateCheckVirtualExperienceScore$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "FCP": "fcp",
    "LCP": "lcp",
    "CLS": "cls",
    "TBT": "tbt",
  });
});

export function updateCheckMetricsFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckMetrics, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckMetrics$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckMetrics' from JSON`,
  );
}

/** @internal */
export const UpdateCheckChecksOutput$inboundSchema: z.ZodType<
  UpdateCheckChecksOutput,
  z.ZodTypeDef,
  unknown
> = z.object({
  metrics: types.optional(z.lazy(() => UpdateCheckMetrics$inboundSchema)),
});

export function updateCheckChecksOutputFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckChecksOutput, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckChecksOutput$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckChecksOutput' from JSON`,
  );
}

/** @internal */
export const UpdateCheckResponseBody$inboundSchema: z.ZodType<
  UpdateCheckResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  name: types.string(),
  createdAt: types.number(),
  updatedAt: types.number(),
  deploymentId: types.string(),
  status: UpdateCheckChecksStatus$inboundSchema,
  conclusion: types.optional(UpdateCheckChecksConclusion$inboundSchema),
  externalId: types.optional(types.string()),
  output: types.optional(z.lazy(() => UpdateCheckChecksOutput$inboundSchema)),
  completedAt: types.optional(types.number()),
  path: types.optional(types.string()),
  blocking: types.boolean(),
  detailsUrl: types.optional(types.string()),
  integrationId: types.string(),
  startedAt: types.optional(types.number()),
  rerequestable: types.optional(types.boolean()),
});

export function updateCheckResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<UpdateCheckResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateCheckResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateCheckResponseBody' from JSON`,
  );
}