/*
 * 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 { ClosedEnum } from "../../types/enums.js";

export type TargetWebOrigin = {
  /**
   * Hostname of the web origin
   */
  hostname: string;
  /**
   * Port number of the web origin
   */
  port: number;
};

/**
 * Rescan of known web property
 */
export type Two = {
  webOrigin: TargetWebOrigin;
};

export const TargetTransportProtocol = {
  Unknown: "unknown",
  Tcp: "tcp",
  Udp: "udp",
  Icmp: "icmp",
  Quic: "quic",
} as const;
export type TargetTransportProtocol = ClosedEnum<
  typeof TargetTransportProtocol
>;

export type TargetServiceId = {
  /**
   * IP address of service
   */
  ip: string;
  /**
   * Port number of service
   */
  port: number;
  /**
   * Name of service protocol
   */
  protocol: string;
  transportProtocol: TargetTransportProtocol;
};

/**
 * Rescan of known service
 */
export type One = {
  serviceId: TargetServiceId;
};

export type ScansRescanInputBodyTarget = One | Two;

export type ScansRescanInputBody = {
  target: One | Two;
};

/** @internal */
export type TargetWebOrigin$Outbound = {
  hostname: string;
  port: number;
};

/** @internal */
export const TargetWebOrigin$outboundSchema: z.ZodType<
  TargetWebOrigin$Outbound,
  z.ZodTypeDef,
  TargetWebOrigin
> = z.object({
  hostname: z.string(),
  port: z.number().int(),
});

export function targetWebOriginToJSON(
  targetWebOrigin: TargetWebOrigin,
): string {
  return JSON.stringify(TargetWebOrigin$outboundSchema.parse(targetWebOrigin));
}

/** @internal */
export type Two$Outbound = {
  web_origin: TargetWebOrigin$Outbound;
};

/** @internal */
export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
  .object({
    webOrigin: z.lazy(() => TargetWebOrigin$outboundSchema),
  }).transform((v) => {
    return remap$(v, {
      webOrigin: "web_origin",
    });
  });

export function twoToJSON(two: Two): string {
  return JSON.stringify(Two$outboundSchema.parse(two));
}

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

/** @internal */
export type TargetServiceId$Outbound = {
  ip: string;
  port: number;
  protocol: string;
  transport_protocol: string;
};

/** @internal */
export const TargetServiceId$outboundSchema: z.ZodType<
  TargetServiceId$Outbound,
  z.ZodTypeDef,
  TargetServiceId
> = z.object({
  ip: z.string(),
  port: z.number().int(),
  protocol: z.string(),
  transportProtocol: TargetTransportProtocol$outboundSchema,
}).transform((v) => {
  return remap$(v, {
    transportProtocol: "transport_protocol",
  });
});

export function targetServiceIdToJSON(
  targetServiceId: TargetServiceId,
): string {
  return JSON.stringify(TargetServiceId$outboundSchema.parse(targetServiceId));
}

/** @internal */
export type One$Outbound = {
  service_id: TargetServiceId$Outbound;
};

/** @internal */
export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
  .object({
    serviceId: z.lazy(() => TargetServiceId$outboundSchema),
  }).transform((v) => {
    return remap$(v, {
      serviceId: "service_id",
    });
  });

export function oneToJSON(one: One): string {
  return JSON.stringify(One$outboundSchema.parse(one));
}

/** @internal */
export type ScansRescanInputBodyTarget$Outbound = One$Outbound | Two$Outbound;

/** @internal */
export const ScansRescanInputBodyTarget$outboundSchema: z.ZodType<
  ScansRescanInputBodyTarget$Outbound,
  z.ZodTypeDef,
  ScansRescanInputBodyTarget
> = z.union([
  z.lazy(() => One$outboundSchema),
  z.lazy(() => Two$outboundSchema),
]);

export function scansRescanInputBodyTargetToJSON(
  scansRescanInputBodyTarget: ScansRescanInputBodyTarget,
): string {
  return JSON.stringify(
    ScansRescanInputBodyTarget$outboundSchema.parse(scansRescanInputBodyTarget),
  );
}

/** @internal */
export type ScansRescanInputBody$Outbound = {
  target: One$Outbound | Two$Outbound;
};

/** @internal */
export const ScansRescanInputBody$outboundSchema: z.ZodType<
  ScansRescanInputBody$Outbound,
  z.ZodTypeDef,
  ScansRescanInputBody
> = z.object({
  target: z.union([
    z.lazy(() => One$outboundSchema),
    z.lazy(() => Two$outboundSchema),
  ]),
});

export function scansRescanInputBodyToJSON(
  scansRescanInputBody: ScansRescanInputBody,
): string {
  return JSON.stringify(
    ScansRescanInputBody$outboundSchema.parse(scansRescanInputBody),
  );
}