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

export type GetActiveAttackStatusRequest = {
  projectId: string;
  since?: number | undefined;
  /**
   * 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;
};

export type AnomalyAlerts = {
  atMinute: string;
  zscore: number;
  totalRequestsMinute: number;
  avgRequests: number;
  stddevRequests: number;
};

export type DdosAlerts = {
  atMinute: string;
  totalReqs: number;
};

export type AffectedHostMap = {
  anomalyAlerts?: { [k: string]: AnomalyAlerts } | undefined;
  ddosAlerts?: { [k: string]: DdosAlerts } | undefined;
};

export type Anomalies = {
  projectId: string;
  ownerId: string;
  startTime: number;
  endTime: number | null;
  atMinute: number;
  state?: string | undefined;
  affectedHostMap: { [k: string]: AffectedHostMap };
};

export type GetActiveAttackStatusResponseBody2 = {
  anomalies: Array<Anomalies>;
};

export type GetActiveAttackStatusResponseBody1 = {};

export type GetActiveAttackStatusResponseBody =
  | GetActiveAttackStatusResponseBody2
  | GetActiveAttackStatusResponseBody1;

/** @internal */
export type GetActiveAttackStatusRequest$Outbound = {
  projectId: string;
  since?: number | undefined;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const GetActiveAttackStatusRequest$outboundSchema: z.ZodType<
  GetActiveAttackStatusRequest$Outbound,
  z.ZodTypeDef,
  GetActiveAttackStatusRequest
> = z.object({
  projectId: z.string(),
  since: z.number().optional(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function getActiveAttackStatusRequestToJSON(
  getActiveAttackStatusRequest: GetActiveAttackStatusRequest,
): string {
  return JSON.stringify(
    GetActiveAttackStatusRequest$outboundSchema.parse(
      getActiveAttackStatusRequest,
    ),
  );
}

/** @internal */
export const AnomalyAlerts$inboundSchema: z.ZodType<
  AnomalyAlerts,
  z.ZodTypeDef,
  unknown
> = z.object({
  at_minute: types.string(),
  zscore: types.number(),
  total_requests_minute: types.number(),
  avg_requests: types.number(),
  stddev_requests: types.number(),
}).transform((v) => {
  return remap$(v, {
    "at_minute": "atMinute",
    "total_requests_minute": "totalRequestsMinute",
    "avg_requests": "avgRequests",
    "stddev_requests": "stddevRequests",
  });
});

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

/** @internal */
export const DdosAlerts$inboundSchema: z.ZodType<
  DdosAlerts,
  z.ZodTypeDef,
  unknown
> = z.object({
  atMinute: types.string(),
  totalReqs: types.number(),
});

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

/** @internal */
export const AffectedHostMap$inboundSchema: z.ZodType<
  AffectedHostMap,
  z.ZodTypeDef,
  unknown
> = z.object({
  anomalyAlerts: types.optional(
    z.record(z.lazy(() => AnomalyAlerts$inboundSchema)),
  ),
  ddosAlerts: types.optional(z.record(z.lazy(() => DdosAlerts$inboundSchema))),
});

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

/** @internal */
export const Anomalies$inboundSchema: z.ZodType<
  Anomalies,
  z.ZodTypeDef,
  unknown
> = z.object({
  projectId: types.string(),
  ownerId: types.string(),
  startTime: types.number(),
  endTime: types.nullable(types.number()),
  atMinute: types.number(),
  state: types.optional(types.string()),
  affectedHostMap: z.record(z.lazy(() => AffectedHostMap$inboundSchema)),
});

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

/** @internal */
export const GetActiveAttackStatusResponseBody2$inboundSchema: z.ZodType<
  GetActiveAttackStatusResponseBody2,
  z.ZodTypeDef,
  unknown
> = z.object({
  anomalies: z.array(z.lazy(() => Anomalies$inboundSchema)),
});

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

/** @internal */
export const GetActiveAttackStatusResponseBody1$inboundSchema: z.ZodType<
  GetActiveAttackStatusResponseBody1,
  z.ZodTypeDef,
  unknown
> = z.object({});

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

/** @internal */
export const GetActiveAttackStatusResponseBody$inboundSchema: z.ZodType<
  GetActiveAttackStatusResponseBody,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => GetActiveAttackStatusResponseBody2$inboundSchema),
  z.lazy(() => GetActiveAttackStatusResponseBody1$inboundSchema),
]);

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