/*
 * 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";

export type CreateCheckRequestBody = {
  /**
   * The name of the check being created
   */
  name: string;
  /**
   * Path of the page that is being checked
   */
  path?: string | undefined;
  /**
   * Whether the check should block a deployment from succeeding
   */
  blocking: boolean;
  /**
   * URL to display for further details
   */
  detailsUrl?: string | undefined;
  /**
   * An identifier that can be used as an external reference
   */
  externalId?: string | undefined;
  /**
   * Whether a user should be able to request for the check to be rerun if it fails
   */
  rerequestable?: boolean | undefined;
};

export type CreateCheckRequest = {
  /**
   * The deployment to create the check for.
   */
  deploymentId: 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: CreateCheckRequestBody;
};

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

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

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

export type CreateCheckFCP = {
  value: number | null;
  previousValue?: number | undefined;
  source: CreateCheckSource;
};

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

export type CreateCheckLCP = {
  value: number | null;
  previousValue?: number | undefined;
  source: CreateCheckChecksSource;
};

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

export type CreateCheckCLS = {
  value: number | null;
  previousValue?: number | undefined;
  source: CreateCheckChecksResponseSource;
};

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

export type CreateCheckTBT = {
  value: number | null;
  previousValue?: number | undefined;
  source: CreateCheckChecksResponse200Source;
};

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

export type CreateCheckVirtualExperienceScore = {
  value: number | null;
  previousValue?: number | undefined;
  source: CreateCheckChecksResponse200ApplicationJSONSource;
};

export type CreateCheckMetrics = {
  fcp: CreateCheckFCP;
  lcp: CreateCheckLCP;
  cls: CreateCheckCLS;
  tbt: CreateCheckTBT;
  virtualExperienceScore?: CreateCheckVirtualExperienceScore | undefined;
};

export type CreateCheckOutput = {
  metrics?: CreateCheckMetrics | undefined;
};

export type CreateCheckResponseBody = {
  id: string;
  name: string;
  createdAt: number;
  updatedAt: number;
  deploymentId: string;
  status: CreateCheckStatus;
  conclusion?: CreateCheckConclusion | undefined;
  externalId?: string | undefined;
  output?: CreateCheckOutput | undefined;
  completedAt?: number | undefined;
  path?: string | undefined;
  blocking: boolean;
  detailsUrl?: string | undefined;
  integrationId: string;
  startedAt?: number | undefined;
  rerequestable?: boolean | undefined;
};

/** @internal */
export type CreateCheckRequestBody$Outbound = {
  name: string;
  path?: string | undefined;
  blocking: boolean;
  detailsUrl?: string | undefined;
  externalId?: string | undefined;
  rerequestable?: boolean | undefined;
};

/** @internal */
export const CreateCheckRequestBody$outboundSchema: z.ZodType<
  CreateCheckRequestBody$Outbound,
  z.ZodTypeDef,
  CreateCheckRequestBody
> = z.object({
  name: z.string(),
  path: z.string().optional(),
  blocking: z.boolean(),
  detailsUrl: z.string().optional(),
  externalId: z.string().optional(),
  rerequestable: z.boolean().optional(),
});

export function createCheckRequestBodyToJSON(
  createCheckRequestBody: CreateCheckRequestBody,
): string {
  return JSON.stringify(
    CreateCheckRequestBody$outboundSchema.parse(createCheckRequestBody),
  );
}

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

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

export function createCheckRequestToJSON(
  createCheckRequest: CreateCheckRequest,
): string {
  return JSON.stringify(
    CreateCheckRequest$outboundSchema.parse(createCheckRequest),
  );
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const CreateCheckMetrics$inboundSchema: z.ZodType<
  CreateCheckMetrics,
  z.ZodTypeDef,
  unknown
> = z.object({
  FCP: z.lazy(() => CreateCheckFCP$inboundSchema),
  LCP: z.lazy(() => CreateCheckLCP$inboundSchema),
  CLS: z.lazy(() => CreateCheckCLS$inboundSchema),
  TBT: z.lazy(() => CreateCheckTBT$inboundSchema),
  virtualExperienceScore: types.optional(
    z.lazy(() => CreateCheckVirtualExperienceScore$inboundSchema),
  ),
}).transform((v) => {
  return remap$(v, {
    "FCP": "fcp",
    "LCP": "lcp",
    "CLS": "cls",
    "TBT": "tbt",
  });
});

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

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

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

/** @internal */
export const CreateCheckResponseBody$inboundSchema: z.ZodType<
  CreateCheckResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  name: types.string(),
  createdAt: types.number(),
  updatedAt: types.number(),
  deploymentId: types.string(),
  status: CreateCheckStatus$inboundSchema,
  conclusion: types.optional(CreateCheckConclusion$inboundSchema),
  externalId: types.optional(types.string()),
  output: types.optional(z.lazy(() => CreateCheckOutput$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 createCheckResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<CreateCheckResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CreateCheckResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CreateCheckResponseBody' from JSON`,
  );
}