@indiciaosint/sdk 1.0.1 → 1.0.3

package/src/models/operations/search-hudson-rock.ts

@@ -0,0 +1,855 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export const SearchHudsonRockTypeRequest = {
+  Domain: "domain",
+  Email: "email",
+  Ip: "ip",
+  Password: "password",
+  Username: "username",
+} as const;
+export type SearchHudsonRockTypeRequest = ClosedEnum<
+  typeof SearchHudsonRockTypeRequest
+>;
+
+export type SearchHudsonRockRequest = {
+  query: string;
+  type: SearchHudsonRockTypeRequest;
+};
+
+export const SearchHudsonRockDataType2 = {
+  Domain: "domain",
+  Email: "email",
+  Ip: "ip",
+  Password: "password",
+  Username: "username",
+} as const;
+export type SearchHudsonRockDataType2 = OpenEnum<
+  typeof SearchHudsonRockDataType2
+>;
+
+export type Stealer = {
+  computerName: string;
+  dateCompromised: string;
+  ip: string;
+  malwarePath: string;
+  operatingSystem: string;
+  topLogins: Array<string>;
+  topPasswords: Array<string>;
+  totalCorporateServices: number;
+  totalUserServices: number;
+  stealerFamily?: string | undefined;
+};
+
+export type SearchHudsonRockData2 = {
+  type: SearchHudsonRockDataType2;
+  message?: string | undefined;
+  stealers?: Array<Stealer> | undefined;
+};
+
+export type Application = {
+  keyword: string;
+};
+
+export type EmployeesUrl = {
+  occurrence: number;
+  type: string;
+  url: string;
+};
+
+export type SearchHudsonRockDataData = {
+  employeesUrls: Array<EmployeesUrl>;
+};
+
+export type SearchHudsonRockStats = {
+  clientsCount: Array<number>;
+  clientsUrls: Array<string>;
+  employeesCount: Array<number>;
+  employeesUrls: Array<string>;
+  totalEmployees: number;
+  totalUsers: number;
+};
+
+export type ThirdPartyDomain = {
+  domain: string;
+  occurrence: number;
+};
+
+export const SearchHudsonRockDataType1 = {
+  Domain: "domain",
+  Email: "email",
+  Ip: "ip",
+  Password: "password",
+  Username: "username",
+} as const;
+export type SearchHudsonRockDataType1 = OpenEnum<
+  typeof SearchHudsonRockDataType1
+>;
+
+export type List = {
+  count: number;
+  name: string;
+};
+
+export type Free = number | string;
+
+export type Antiviruses = {
+  list: Array<List>;
+  found?: number | undefined;
+  free?: number | string | undefined;
+  notFound?: string | undefined;
+  total?: number | undefined;
+};
+
+export type EmployeePasswordsMedium = {
+  perc: number;
+  qty: number;
+};
+
+export type EmployeePasswordsStrong = {
+  perc: number;
+  qty: number;
+};
+
+export type EmployeePasswordsTooWeak = {
+  perc: number;
+  qty: number;
+};
+
+export type EmployeePasswordsWeak = {
+  perc: number;
+  qty: number;
+};
+
+export type EmployeePasswords = {
+  hasStats: boolean;
+  medium: EmployeePasswordsMedium;
+  strong: EmployeePasswordsStrong;
+  tooWeak: EmployeePasswordsTooWeak;
+  totalPass: number;
+  weak: EmployeePasswordsWeak;
+};
+
+export type StealerFamilies = {
+  acreed: number;
+  atomic: number;
+  azorult: number;
+  cryptbot: number;
+  darkCrystal: number;
+  ficker: number;
+  genericStealer: number;
+  lumma: number;
+  mystic: number;
+  predator: number;
+  raccoon: number;
+  redLine: number;
+  stealC: number;
+  taurus: number;
+  unknown: number;
+  vidar: number;
+  lastCounted: string;
+  total: number;
+};
+
+export type UserPasswordsMedium = {
+  perc: number;
+  qty: number;
+};
+
+export type UserPasswordsStrong = {
+  perc: number;
+  qty: number;
+};
+
+export type UserPasswordsTooWeak = {
+  perc: number;
+  qty: number;
+};
+
+export type UserPasswordsWeak = {
+  perc: number;
+  qty: number;
+};
+
+export type UserPasswords = {
+  hasStats: boolean;
+  medium: UserPasswordsMedium;
+  strong: UserPasswordsStrong;
+  tooWeak: UserPasswordsTooWeak;
+  totalPass: number;
+  weak: UserPasswordsWeak;
+};
+
+export type SearchHudsonRockData1 = {
+  applications: Array<Application>;
+  data: SearchHudsonRockDataData;
+  employees: number;
+  isShopify: boolean;
+  lastEmployeeCompromised: string;
+  lastUserCompromised: string;
+  logo: string;
+  stats: SearchHudsonRockStats;
+  thirdPartyDomains: Array<ThirdPartyDomain>;
+  thirdParties: number;
+  total: number;
+  totalStealers: number;
+  totalUrls: number;
+  type: SearchHudsonRockDataType1;
+  users: number;
+  antiviruses?: Antiviruses | undefined;
+  employeePasswords?: EmployeePasswords | undefined;
+  stealerFamilies?: StealerFamilies | undefined;
+  userPasswords?: UserPasswords | undefined;
+};
+
+export type Data = SearchHudsonRockData1 | SearchHudsonRockData2;
+
+/**
+ * Search successful
+ */
+export type SearchHudsonRockResponse = {
+  data: SearchHudsonRockData1 | SearchHudsonRockData2;
+  success: boolean;
+  error?: string | undefined;
+};
+
+/** @internal */
+export const SearchHudsonRockTypeRequest$outboundSchema: z.ZodMiniEnum<
+  typeof SearchHudsonRockTypeRequest
+> = z.enum(SearchHudsonRockTypeRequest);
+
+/** @internal */
+export type SearchHudsonRockRequest$Outbound = {
+  query: string;
+  type: string;
+};
+
+/** @internal */
+export const SearchHudsonRockRequest$outboundSchema: z.ZodMiniType<
+  SearchHudsonRockRequest$Outbound,
+  SearchHudsonRockRequest
+> = z.object({
+  query: z.string(),
+  type: SearchHudsonRockTypeRequest$outboundSchema,
+});
+
+export function searchHudsonRockRequestToJSON(
+  searchHudsonRockRequest: SearchHudsonRockRequest,
+): string {
+  return JSON.stringify(
+    SearchHudsonRockRequest$outboundSchema.parse(searchHudsonRockRequest),
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockDataType2$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockDataType2,
+  unknown
+> = openEnums.inboundSchema(SearchHudsonRockDataType2);
+
+/** @internal */
+export const Stealer$inboundSchema: z.ZodMiniType<Stealer, unknown> = z.pipe(
+  z.object({
+    computer_name: types.string(),
+    date_compromised: types.string(),
+    ip: types.string(),
+    malware_path: types.string(),
+    operating_system: types.string(),
+    top_logins: z.array(types.string()),
+    top_passwords: z.array(types.string()),
+    total_corporate_services: types.number(),
+    total_user_services: types.number(),
+    stealer_family: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "computer_name": "computerName",
+      "date_compromised": "dateCompromised",
+      "malware_path": "malwarePath",
+      "operating_system": "operatingSystem",
+      "top_logins": "topLogins",
+      "top_passwords": "topPasswords",
+      "total_corporate_services": "totalCorporateServices",
+      "total_user_services": "totalUserServices",
+      "stealer_family": "stealerFamily",
+    });
+  }),
+);
+
+export function stealerFromJSON(
+  jsonString: string,
+): SafeParseResult<Stealer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Stealer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Stealer' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockData2$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockData2,
+  unknown
+> = z.object({
+  type: SearchHudsonRockDataType2$inboundSchema,
+  message: types.optional(types.string()),
+  stealers: types.optional(z.array(z.lazy(() => Stealer$inboundSchema))),
+});
+
+export function searchHudsonRockData2FromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHudsonRockData2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHudsonRockData2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHudsonRockData2' from JSON`,
+  );
+}
+
+/** @internal */
+export const Application$inboundSchema: z.ZodMiniType<Application, unknown> = z
+  .object({
+    keyword: types.string(),
+  });
+
+export function applicationFromJSON(
+  jsonString: string,
+): SafeParseResult<Application, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Application$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Application' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmployeesUrl$inboundSchema: z.ZodMiniType<EmployeesUrl, unknown> =
+  z.object({
+    occurrence: types.number(),
+    type: types.string(),
+    url: types.string(),
+  });
+
+export function employeesUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<EmployeesUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmployeesUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmployeesUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockDataData$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockDataData,
+  unknown
+> = z.pipe(
+  z.object({
+    employees_urls: z.array(z.lazy(() => EmployeesUrl$inboundSchema)),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "employees_urls": "employeesUrls",
+    });
+  }),
+);
+
+export function searchHudsonRockDataDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHudsonRockDataData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHudsonRockDataData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHudsonRockDataData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockStats$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockStats,
+  unknown
+> = z.pipe(
+  z.object({
+    clients_count: z.array(types.number()),
+    clients_urls: z.array(types.string()),
+    employees_count: z.array(types.number()),
+    employees_urls: z.array(types.string()),
+    totalEmployees: types.number(),
+    totalUsers: types.number(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "clients_count": "clientsCount",
+      "clients_urls": "clientsUrls",
+      "employees_count": "employeesCount",
+      "employees_urls": "employeesUrls",
+    });
+  }),
+);
+
+export function searchHudsonRockStatsFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHudsonRockStats, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHudsonRockStats$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHudsonRockStats' from JSON`,
+  );
+}
+
+/** @internal */
+export const ThirdPartyDomain$inboundSchema: z.ZodMiniType<
+  ThirdPartyDomain,
+  unknown
+> = z.object({
+  domain: types.string(),
+  occurrence: types.number(),
+});
+
+export function thirdPartyDomainFromJSON(
+  jsonString: string,
+): SafeParseResult<ThirdPartyDomain, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThirdPartyDomain$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThirdPartyDomain' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockDataType1$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockDataType1,
+  unknown
+> = openEnums.inboundSchema(SearchHudsonRockDataType1);
+
+/** @internal */
+export const List$inboundSchema: z.ZodMiniType<List, unknown> = z.object({
+  count: types.number(),
+  name: types.string(),
+});
+
+export function listFromJSON(
+  jsonString: string,
+): SafeParseResult<List, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => List$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'List' from JSON`,
+  );
+}
+
+/** @internal */
+export const Free$inboundSchema: z.ZodMiniType<Free, unknown> = smartUnion([
+  types.number(),
+  types.string(),
+]);
+
+export function freeFromJSON(
+  jsonString: string,
+): SafeParseResult<Free, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Free$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Free' from JSON`,
+  );
+}
+
+/** @internal */
+export const Antiviruses$inboundSchema: z.ZodMiniType<Antiviruses, unknown> = z
+  .pipe(
+    z.object({
+      list: z.array(z.lazy(() => List$inboundSchema)),
+      found: types.optional(types.number()),
+      free: types.optional(smartUnion([types.number(), types.string()])),
+      not_found: types.optional(types.string()),
+      total: types.optional(types.number()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "not_found": "notFound",
+      });
+    }),
+  );
+
+export function antivirusesFromJSON(
+  jsonString: string,
+): SafeParseResult<Antiviruses, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Antiviruses$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Antiviruses' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmployeePasswordsMedium$inboundSchema: z.ZodMiniType<
+  EmployeePasswordsMedium,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function employeePasswordsMediumFromJSON(
+  jsonString: string,
+): SafeParseResult<EmployeePasswordsMedium, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmployeePasswordsMedium$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmployeePasswordsMedium' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmployeePasswordsStrong$inboundSchema: z.ZodMiniType<
+  EmployeePasswordsStrong,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function employeePasswordsStrongFromJSON(
+  jsonString: string,
+): SafeParseResult<EmployeePasswordsStrong, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmployeePasswordsStrong$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmployeePasswordsStrong' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmployeePasswordsTooWeak$inboundSchema: z.ZodMiniType<
+  EmployeePasswordsTooWeak,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function employeePasswordsTooWeakFromJSON(
+  jsonString: string,
+): SafeParseResult<EmployeePasswordsTooWeak, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmployeePasswordsTooWeak$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmployeePasswordsTooWeak' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmployeePasswordsWeak$inboundSchema: z.ZodMiniType<
+  EmployeePasswordsWeak,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function employeePasswordsWeakFromJSON(
+  jsonString: string,
+): SafeParseResult<EmployeePasswordsWeak, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmployeePasswordsWeak$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmployeePasswordsWeak' from JSON`,
+  );
+}
+
+/** @internal */
+export const EmployeePasswords$inboundSchema: z.ZodMiniType<
+  EmployeePasswords,
+  unknown
+> = z.pipe(
+  z.object({
+    has_stats: types.boolean(),
+    medium: z.lazy(() => EmployeePasswordsMedium$inboundSchema),
+    strong: z.lazy(() => EmployeePasswordsStrong$inboundSchema),
+    too_weak: z.lazy(() => EmployeePasswordsTooWeak$inboundSchema),
+    totalPass: types.number(),
+    weak: z.lazy(() => EmployeePasswordsWeak$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "has_stats": "hasStats",
+      "too_weak": "tooWeak",
+    });
+  }),
+);
+
+export function employeePasswordsFromJSON(
+  jsonString: string,
+): SafeParseResult<EmployeePasswords, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EmployeePasswords$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EmployeePasswords' from JSON`,
+  );
+}
+
+/** @internal */
+export const StealerFamilies$inboundSchema: z.ZodMiniType<
+  StealerFamilies,
+  unknown
+> = z.pipe(
+  z.object({
+    Acreed: types.number(),
+    Atomic: types.number(),
+    Azorult: types.number(),
+    CRYPTBOT: types.number(),
+    DarkCrystal: types.number(),
+    Ficker: types.number(),
+    "Generic Stealer": types.number(),
+    Lumma: types.number(),
+    Mystic: types.number(),
+    Predator: types.number(),
+    Raccoon: types.number(),
+    RedLine: types.number(),
+    StealC: types.number(),
+    Taurus: types.number(),
+    UNKNOWN: types.number(),
+    Vidar: types.number(),
+    last_counted: types.string(),
+    total: types.number(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "Acreed": "acreed",
+      "Atomic": "atomic",
+      "Azorult": "azorult",
+      "CRYPTBOT": "cryptbot",
+      "DarkCrystal": "darkCrystal",
+      "Ficker": "ficker",
+      "Generic Stealer": "genericStealer",
+      "Lumma": "lumma",
+      "Mystic": "mystic",
+      "Predator": "predator",
+      "Raccoon": "raccoon",
+      "RedLine": "redLine",
+      "StealC": "stealC",
+      "Taurus": "taurus",
+      "UNKNOWN": "unknown",
+      "Vidar": "vidar",
+      "last_counted": "lastCounted",
+    });
+  }),
+);
+
+export function stealerFamiliesFromJSON(
+  jsonString: string,
+): SafeParseResult<StealerFamilies, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StealerFamilies$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StealerFamilies' from JSON`,
+  );
+}
+
+/** @internal */
+export const UserPasswordsMedium$inboundSchema: z.ZodMiniType<
+  UserPasswordsMedium,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function userPasswordsMediumFromJSON(
+  jsonString: string,
+): SafeParseResult<UserPasswordsMedium, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserPasswordsMedium$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserPasswordsMedium' from JSON`,
+  );
+}
+
+/** @internal */
+export const UserPasswordsStrong$inboundSchema: z.ZodMiniType<
+  UserPasswordsStrong,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function userPasswordsStrongFromJSON(
+  jsonString: string,
+): SafeParseResult<UserPasswordsStrong, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserPasswordsStrong$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserPasswordsStrong' from JSON`,
+  );
+}
+
+/** @internal */
+export const UserPasswordsTooWeak$inboundSchema: z.ZodMiniType<
+  UserPasswordsTooWeak,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function userPasswordsTooWeakFromJSON(
+  jsonString: string,
+): SafeParseResult<UserPasswordsTooWeak, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserPasswordsTooWeak$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserPasswordsTooWeak' from JSON`,
+  );
+}
+
+/** @internal */
+export const UserPasswordsWeak$inboundSchema: z.ZodMiniType<
+  UserPasswordsWeak,
+  unknown
+> = z.object({
+  perc: types.number(),
+  qty: types.number(),
+});
+
+export function userPasswordsWeakFromJSON(
+  jsonString: string,
+): SafeParseResult<UserPasswordsWeak, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserPasswordsWeak$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserPasswordsWeak' from JSON`,
+  );
+}
+
+/** @internal */
+export const UserPasswords$inboundSchema: z.ZodMiniType<
+  UserPasswords,
+  unknown
+> = z.pipe(
+  z.object({
+    has_stats: types.boolean(),
+    medium: z.lazy(() => UserPasswordsMedium$inboundSchema),
+    strong: z.lazy(() => UserPasswordsStrong$inboundSchema),
+    too_weak: z.lazy(() => UserPasswordsTooWeak$inboundSchema),
+    totalPass: types.number(),
+    weak: z.lazy(() => UserPasswordsWeak$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "has_stats": "hasStats",
+      "too_weak": "tooWeak",
+    });
+  }),
+);
+
+export function userPasswordsFromJSON(
+  jsonString: string,
+): SafeParseResult<UserPasswords, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UserPasswords$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UserPasswords' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockData1$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockData1,
+  unknown
+> = z.pipe(
+  z.object({
+    applications: z.array(z.lazy(() => Application$inboundSchema)),
+    data: z.lazy(() => SearchHudsonRockDataData$inboundSchema),
+    employees: types.number(),
+    is_shopify: types.boolean(),
+    last_employee_compromised: types.string(),
+    last_user_compromised: types.string(),
+    logo: types.string(),
+    stats: z.lazy(() => SearchHudsonRockStats$inboundSchema),
+    thirdPartyDomains: z.array(z.lazy(() => ThirdPartyDomain$inboundSchema)),
+    third_parties: types.number(),
+    total: types.number(),
+    totalStealers: types.number(),
+    totalUrls: types.number(),
+    type: SearchHudsonRockDataType1$inboundSchema,
+    users: types.number(),
+    antiviruses: types.optional(z.lazy(() => Antiviruses$inboundSchema)),
+    employeePasswords: types.optional(
+      z.lazy(() => EmployeePasswords$inboundSchema),
+    ),
+    stealerFamilies: types.optional(
+      z.lazy(() => StealerFamilies$inboundSchema),
+    ),
+    userPasswords: types.optional(z.lazy(() => UserPasswords$inboundSchema)),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "is_shopify": "isShopify",
+      "last_employee_compromised": "lastEmployeeCompromised",
+      "last_user_compromised": "lastUserCompromised",
+      "third_parties": "thirdParties",
+    });
+  }),
+);
+
+export function searchHudsonRockData1FromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHudsonRockData1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHudsonRockData1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHudsonRockData1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Data$inboundSchema: z.ZodMiniType<Data, unknown> = smartUnion([
+  z.lazy(() => SearchHudsonRockData1$inboundSchema),
+  z.lazy(() => SearchHudsonRockData2$inboundSchema),
+]);
+
+export function dataFromJSON(
+  jsonString: string,
+): SafeParseResult<Data, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Data$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Data' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchHudsonRockResponse$inboundSchema: z.ZodMiniType<
+  SearchHudsonRockResponse,
+  unknown
+> = z.object({
+  data: smartUnion([
+    z.lazy(() => SearchHudsonRockData1$inboundSchema),
+    z.lazy(() => SearchHudsonRockData2$inboundSchema),
+  ]),
+  success: types.boolean(),
+  error: types.optional(types.string()),
+});
+
+export function searchHudsonRockResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHudsonRockResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHudsonRockResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHudsonRockResponse' from JSON`,
+  );
+}