@indiciaosint/sdk 0.0.1 → 1.0.1-patch

package/src/models/operations/search-web-databases.ts

@@ -0,0 +1,1640 @@
+/*
+ * 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 {
+  collectExtraKeys as collectExtraKeys$,
+  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 Service = {
+  Cloudsint: "cloudsint",
+  IntelligencexIdentityportal: "intelligencex.identityportal",
+  Leakcheck: "leakcheck",
+  Snusbase: "snusbase",
+} as const;
+export type Service = ClosedEnum<typeof Service>;
+
+export const CloudsintTypeRequest = {
+  Discordid: "discordid",
+  Email: "email",
+  Ip: "ip",
+  Name: "name",
+  Password: "password",
+  Phone: "phone",
+  Steamid: "steamid",
+  Url: "url",
+  Username: "username",
+} as const;
+export type CloudsintTypeRequest = ClosedEnum<typeof CloudsintTypeRequest>;
+
+export const IntelxType = {
+  Domain: "domain",
+  Email: "email",
+  Ip: "ip",
+  Phone: "phone",
+  Url: "url",
+} as const;
+export type IntelxType = ClosedEnum<typeof IntelxType>;
+
+export const LeakCheckType = {
+  Auto: "auto",
+  Domain: "domain",
+  Email: "email",
+  Hash: "hash",
+  Keyword: "keyword",
+  Origin: "origin",
+  Password: "password",
+  Phash: "phash",
+  Phone: "phone",
+  Username: "username",
+} as const;
+export type LeakCheckType = ClosedEnum<typeof LeakCheckType>;
+
+export const SnusbaseType = {
+  Domain: "_domain",
+  Email: "email",
+  Hash: "hash",
+  Lastip: "lastip",
+  Name: "name",
+  Password: "password",
+  Phone: "phone",
+  Username: "username",
+  Wildcard: "wildcard",
+} as const;
+export type SnusbaseType = ClosedEnum<typeof SnusbaseType>;
+
+export type SearchWebDatabasesRequest = {
+  query: string;
+  services: Array<Service>;
+  cloudsintType?: CloudsintTypeRequest | undefined;
+  intelxType?: IntelxType | undefined;
+  leakCheckType?: LeakCheckType | undefined;
+  snusbaseType?: SnusbaseType | undefined;
+};
+
+export type SearchWebDatabasesBreach = {
+  email: string;
+  id: string;
+  importedAt: string;
+  password: string;
+  source: string;
+  sourceDate: string;
+  sourceName: string;
+  url: string;
+  username: string;
+};
+
+export const CloudsintTypeResponse = {
+  Discordid: "discordid",
+  Email: "email",
+  Ip: "ip",
+  Name: "name",
+  Password: "password",
+  Phone: "phone",
+  Steamid: "steamid",
+  Url: "url",
+  Username: "username",
+} as const;
+export type CloudsintTypeResponse = OpenEnum<typeof CloudsintTypeResponse>;
+
+export type SearchWebDatabasesData = {
+  breaches: Array<SearchWebDatabasesBreach>;
+  query: string;
+  totalMatches: number;
+  type: CloudsintTypeResponse;
+};
+
+export type Cloudsint = {
+  data: SearchWebDatabasesData;
+  duration: number;
+  success: boolean;
+};
+
+export type LogInfo = {
+  hwid: string | null;
+  name: string | null;
+  systemName: string | null;
+};
+
+export type Credential = {
+  logInfo: LogInfo;
+  date?: string | undefined;
+  login?: string | undefined;
+  password?: string | undefined;
+  url?: string | undefined;
+};
+
+export type Ghosint = {
+  count: number;
+  credentials: Array<Credential>;
+  resultId: string;
+};
+
+export type ResultsSource = {
+  date?: string | undefined;
+  name?: string | undefined;
+};
+
+export type ResultsResults = {
+  id: string;
+  source: ResultsSource;
+  email?: string | undefined;
+  fullName?: string | undefined;
+  hash?: string | undefined;
+  ipAddress?: string | undefined;
+  otherFields?: { [k: string]: string } | undefined;
+  password?: string | undefined;
+  phoneNumber?: string | undefined;
+  sensitiveFields?: { [k: string]: string } | undefined;
+  username?: string | undefined;
+};
+
+export type Results = {
+  databases: number;
+  firstSeen: string;
+  found: number;
+  lastSeen: string;
+  results: ResultsResults;
+};
+
+export type Hackcheck = {
+  results: Results;
+};
+
+export type Tag = {
+  class: number;
+  value: string;
+};
+
+export type Item = {
+  accesslevel?: number | undefined;
+  added?: string | undefined;
+  bucket?: string | undefined;
+  date?: string | undefined;
+  description?: string | undefined;
+  instore?: boolean | undefined;
+  keyvalues?: any | undefined;
+  media?: number | undefined;
+  name?: string | undefined;
+  owner?: string | undefined;
+  relations?: any | undefined;
+  simhash?: number | undefined;
+  size?: number | undefined;
+  storageid?: string | undefined;
+  systemid?: string | undefined;
+  tags?: Array<Tag> | undefined;
+  type?: number | undefined;
+  xscore?: number | undefined;
+};
+
+export type Identityportal = {
+  linea: string;
+  item?: Item | undefined;
+  lineraw?: string | undefined;
+  linesafterraw?: string | null | undefined;
+  linesbeforeraw?: string | null | undefined;
+  positionabsolute?: number | undefined;
+  positionline?: number | undefined;
+  positionsize?: number | undefined;
+};
+
+export type Intelligencex = {
+  identityportal?: Array<Identityportal> | undefined;
+};
+
+export const Compilation = {
+  Zero: "0",
+  One: "1",
+} as const;
+export type Compilation = OpenEnum<typeof Compilation>;
+
+export const Passwordless = {
+  Zero: "0",
+  One: "1",
+} as const;
+export type Passwordless = OpenEnum<typeof Passwordless>;
+
+export const Unverified = {
+  Zero: "0",
+  One: "1",
+} as const;
+export type Unverified = OpenEnum<typeof Unverified>;
+
+export type ResultSource = {
+  breachDate: string;
+  compilation: Compilation;
+  name: string;
+  passwordless: Passwordless;
+  unverified: Unverified;
+};
+
+export type SearchWebDatabasesResult = {
+  address: string | null;
+  country: string | null;
+  dob: string | null;
+  email: string | null;
+  fields: Array<string>;
+  firstName: string | null;
+  lastName: string | null;
+  name: string | null;
+  password: string | null;
+  phone: string | null;
+  source: ResultSource;
+  state: string | null;
+  zip: string | null;
+};
+
+export type Leakcheck = {
+  error: string | null;
+  found: number;
+  quota: number | null;
+  result: Array<SearchWebDatabasesResult>;
+  success: boolean;
+};
+
+export type Datum = {
+  email?: string | undefined;
+  nickName?: string | undefined;
+  password?: string | undefined;
+  url?: string | undefined;
+  additionalProperties?: { [k: string]: string | null } | undefined;
+};
+
+export type SearchWebDatabasesList = {
+  data: Array<Datum>;
+  infoLeak: string;
+  numOfResults: number;
+};
+
+export type Leakosint = {
+  list: { [k: string]: SearchWebDatabasesList };
+  numOfDatabase: number;
+  numOfResults: number;
+  price: number;
+  searchTime: number;
+};
+
+export type Body = {
+  bio?: string | undefined;
+  additionalProperties?: { [k: string]: string | null } | undefined;
+};
+
+export type SearchWebDatabasesTimeline = {
+  groupItems: { [k: string]: any };
+  groupYears: { [k: string]: any };
+  groups: { [k: string]: any };
+  lastSeen: boolean;
+  lastSeenDate: string | null;
+  registered: boolean;
+  registeredDate: string | null;
+};
+
+export type FrontSchema = {
+  body: Body;
+  image: string;
+  module: string;
+  tags: Array<string>;
+  timeline: SearchWebDatabasesTimeline;
+};
+
+export type Bio = {
+  properKey: string;
+  type: "str";
+  value: string;
+};
+
+export type SearchWebDatabasesId = {
+  properKey: string;
+  type: "str";
+  value: string;
+};
+
+export type SearchWebDatabasesLocation = {
+  properKey: string;
+  type: "str";
+  value: string;
+};
+
+export type Name = {
+  properKey: string;
+  type: "str";
+  value: string;
+};
+
+export type PictureUrl = {
+  properKey: string;
+  type: "str";
+  value: string;
+};
+
+export const PlatformVariableType = {
+  Bool: "bool",
+  List: "list",
+  Number: "number",
+  Str: "str",
+} as const;
+export type PlatformVariableType = OpenEnum<typeof PlatformVariableType>;
+
+export type Value = {
+  url: string;
+};
+
+export type ValueUnion = number | string | Array<Value> | boolean;
+
+export type PlatformVariable = {
+  key: string;
+  properKey: string;
+  type: PlatformVariableType;
+  value: number | string | Array<Value> | boolean;
+};
+
+export type Private = {
+  properKey: string;
+  type: "bool";
+  value: boolean;
+};
+
+export type ProfileUrl = {
+  properKey: string;
+  type: "str";
+  value: string;
+};
+
+export type Registered = {
+  properKey: string;
+  type: "bool";
+  value: boolean;
+};
+
+export type Verified = {
+  properKey: string;
+  type: "bool";
+  value: boolean;
+};
+
+export type SpecFormat = {
+  bio?: Bio | undefined;
+  id?: SearchWebDatabasesId | undefined;
+  location?: SearchWebDatabasesLocation | undefined;
+  name?: Name | undefined;
+  pictureUrl?: PictureUrl | undefined;
+  platformVariables?: Array<PlatformVariable> | undefined;
+  private?: Private | undefined;
+  profileUrl?: ProfileUrl | undefined;
+  registered?: Registered | undefined;
+  verified?: Verified | undefined;
+};
+
+export const SearchWebDatabasesStatus = {
+  Found: "found",
+  NotFound: "not_found",
+} as const;
+export type SearchWebDatabasesStatus = OpenEnum<
+  typeof SearchWebDatabasesStatus
+>;
+
+export type Category = {
+  name: string;
+};
+
+export type Osintindustry = {
+  data: { [k: string]: any };
+  frontSchemas: Array<FrontSchema>;
+  module: string;
+  reliableSource: boolean;
+  specFormat: Array<SpecFormat>;
+  status: SearchWebDatabasesStatus;
+  category?: Category | undefined;
+};
+
+export type Snusbase = {
+  address?: string | undefined;
+  birthdate?: string | undefined;
+  city?: string | undefined;
+  company?: string | undefined;
+  country?: string | undefined;
+  created?: string | undefined;
+  date?: string | undefined;
+  domain?: string | undefined;
+  email?: string | undefined;
+  followers?: string | undefined;
+  gender?: string | undefined;
+  hash?: string | undefined;
+  host?: string | undefined;
+  id?: string | undefined;
+  job?: string | undefined;
+  language?: string | undefined;
+  lastip?: string | undefined;
+  name?: string | undefined;
+  other?: string | undefined;
+  password?: string | undefined;
+  phone?: string | undefined;
+  regip?: string | undefined;
+  salt?: string | undefined;
+  state?: string | undefined;
+  uid?: string | undefined;
+  unparsed?: string | undefined;
+  updated?: string | undefined;
+  url?: string | undefined;
+  username?: string | undefined;
+  zip?: string | undefined;
+};
+
+export type ResponseT = {
+  cloudsint?: Cloudsint | undefined;
+  ghosint?: Ghosint | undefined;
+  hackcheck?: Hackcheck | undefined;
+  intelligencex?: Intelligencex | undefined;
+  leakcheck?: Leakcheck | undefined;
+  leakosint?: Leakosint | undefined;
+  osintindustries?: Array<Osintindustry> | undefined;
+  snusbase?: { [k: string]: Array<Snusbase> } | undefined;
+};
+
+/**
+ * Search successful
+ */
+export type SearchWebDatabasesResponse = {
+  response: ResponseT;
+  success: boolean;
+  error?: string | undefined;
+};
+
+/** @internal */
+export const Service$outboundSchema: z.ZodMiniEnum<typeof Service> = z.enum(
+  Service,
+);
+
+/** @internal */
+export const CloudsintTypeRequest$outboundSchema: z.ZodMiniEnum<
+  typeof CloudsintTypeRequest
+> = z.enum(CloudsintTypeRequest);
+
+/** @internal */
+export const IntelxType$outboundSchema: z.ZodMiniEnum<typeof IntelxType> = z
+  .enum(IntelxType);
+
+/** @internal */
+export const LeakCheckType$outboundSchema: z.ZodMiniEnum<typeof LeakCheckType> =
+  z.enum(LeakCheckType);
+
+/** @internal */
+export const SnusbaseType$outboundSchema: z.ZodMiniEnum<typeof SnusbaseType> = z
+  .enum(SnusbaseType);
+
+/** @internal */
+export type SearchWebDatabasesRequest$Outbound = {
+  query: string;
+  services: Array<string>;
+  cloudsintType?: string | undefined;
+  intelxType?: string | undefined;
+  leakCheckType?: string | undefined;
+  snusbaseType?: string | undefined;
+};
+
+/** @internal */
+export const SearchWebDatabasesRequest$outboundSchema: z.ZodMiniType<
+  SearchWebDatabasesRequest$Outbound,
+  SearchWebDatabasesRequest
+> = z.object({
+  query: z.string(),
+  services: z.array(Service$outboundSchema),
+  cloudsintType: z.optional(CloudsintTypeRequest$outboundSchema),
+  intelxType: z.optional(IntelxType$outboundSchema),
+  leakCheckType: z.optional(LeakCheckType$outboundSchema),
+  snusbaseType: z.optional(SnusbaseType$outboundSchema),
+});
+
+export function searchWebDatabasesRequestToJSON(
+  searchWebDatabasesRequest: SearchWebDatabasesRequest,
+): string {
+  return JSON.stringify(
+    SearchWebDatabasesRequest$outboundSchema.parse(searchWebDatabasesRequest),
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesBreach$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesBreach,
+  unknown
+> = z.pipe(
+  z.object({
+    email: types.string(),
+    id: types.string(),
+    imported_at: types.string(),
+    password: types.string(),
+    source: types.string(),
+    source_date: types.string(),
+    source_name: types.string(),
+    url: types.string(),
+    username: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "imported_at": "importedAt",
+      "source_date": "sourceDate",
+      "source_name": "sourceName",
+    });
+  }),
+);
+
+export function searchWebDatabasesBreachFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesBreach, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesBreach$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesBreach' from JSON`,
+  );
+}
+
+/** @internal */
+export const CloudsintTypeResponse$inboundSchema: z.ZodMiniType<
+  CloudsintTypeResponse,
+  unknown
+> = openEnums.inboundSchema(CloudsintTypeResponse);
+
+/** @internal */
+export const SearchWebDatabasesData$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesData,
+  unknown
+> = z.pipe(
+  z.object({
+    breaches: z.array(z.lazy(() => SearchWebDatabasesBreach$inboundSchema)),
+    query: types.string(),
+    total_matches: types.number(),
+    type: CloudsintTypeResponse$inboundSchema,
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "total_matches": "totalMatches",
+    });
+  }),
+);
+
+export function searchWebDatabasesDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesData' from JSON`,
+  );
+}
+
+/** @internal */
+export const Cloudsint$inboundSchema: z.ZodMiniType<Cloudsint, unknown> = z
+  .object({
+    data: z.lazy(() => SearchWebDatabasesData$inboundSchema),
+    duration: types.number(),
+    success: types.boolean(),
+  });
+
+export function cloudsintFromJSON(
+  jsonString: string,
+): SafeParseResult<Cloudsint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Cloudsint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Cloudsint' from JSON`,
+  );
+}
+
+/** @internal */
+export const LogInfo$inboundSchema: z.ZodMiniType<LogInfo, unknown> = z.pipe(
+  z.object({
+    hwid: types.nullable(types.string()),
+    name: types.nullable(types.string()),
+    system_name: types.nullable(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "system_name": "systemName",
+    });
+  }),
+);
+
+export function logInfoFromJSON(
+  jsonString: string,
+): SafeParseResult<LogInfo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LogInfo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LogInfo' from JSON`,
+  );
+}
+
+/** @internal */
+export const Credential$inboundSchema: z.ZodMiniType<Credential, unknown> = z
+  .pipe(
+    z.object({
+      log_info: z.lazy(() => LogInfo$inboundSchema),
+      date: types.optional(types.string()),
+      login: types.optional(types.string()),
+      password: types.optional(types.string()),
+      url: types.optional(types.string()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "log_info": "logInfo",
+      });
+    }),
+  );
+
+export function credentialFromJSON(
+  jsonString: string,
+): SafeParseResult<Credential, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Credential$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Credential' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ghosint$inboundSchema: z.ZodMiniType<Ghosint, unknown> = z.pipe(
+  z.object({
+    count: types.number(),
+    credentials: z.array(z.lazy(() => Credential$inboundSchema)),
+    result_id: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "result_id": "resultId",
+    });
+  }),
+);
+
+export function ghosintFromJSON(
+  jsonString: string,
+): SafeParseResult<Ghosint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ghosint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ghosint' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResultsSource$inboundSchema: z.ZodMiniType<
+  ResultsSource,
+  unknown
+> = z.object({
+  date: types.optional(types.string()),
+  name: types.optional(types.string()),
+});
+
+export function resultsSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<ResultsSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResultsSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResultsSource' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResultsResults$inboundSchema: z.ZodMiniType<
+  ResultsResults,
+  unknown
+> = z.pipe(
+  z.object({
+    id: types.string(),
+    source: z.lazy(() => ResultsSource$inboundSchema),
+    email: types.optional(types.string()),
+    full_name: types.optional(types.string()),
+    hash: types.optional(types.string()),
+    ip_address: types.optional(types.string()),
+    other_fields: types.optional(z.record(z.string(), types.string())),
+    password: types.optional(types.string()),
+    phone_number: types.optional(types.string()),
+    sensitive_fields: types.optional(z.record(z.string(), types.string())),
+    username: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "full_name": "fullName",
+      "ip_address": "ipAddress",
+      "other_fields": "otherFields",
+      "phone_number": "phoneNumber",
+      "sensitive_fields": "sensitiveFields",
+    });
+  }),
+);
+
+export function resultsResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<ResultsResults, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResultsResults$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResultsResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const Results$inboundSchema: z.ZodMiniType<Results, unknown> = z.pipe(
+  z.object({
+    databases: types.number(),
+    first_seen: types.string(),
+    found: types.number(),
+    last_seen: types.string(),
+    results: z.lazy(() => ResultsResults$inboundSchema),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "first_seen": "firstSeen",
+      "last_seen": "lastSeen",
+    });
+  }),
+);
+
+export function resultsFromJSON(
+  jsonString: string,
+): SafeParseResult<Results, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Results$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Results' from JSON`,
+  );
+}
+
+/** @internal */
+export const Hackcheck$inboundSchema: z.ZodMiniType<Hackcheck, unknown> = z
+  .object({
+    results: z.lazy(() => Results$inboundSchema),
+  });
+
+export function hackcheckFromJSON(
+  jsonString: string,
+): SafeParseResult<Hackcheck, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Hackcheck$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Hackcheck' from JSON`,
+  );
+}
+
+/** @internal */
+export const Tag$inboundSchema: z.ZodMiniType<Tag, unknown> = z.object({
+  class: types.number(),
+  value: types.string(),
+});
+
+export function tagFromJSON(
+  jsonString: string,
+): SafeParseResult<Tag, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Tag$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Tag' from JSON`,
+  );
+}
+
+/** @internal */
+export const Item$inboundSchema: z.ZodMiniType<Item, unknown> = z.object({
+  accesslevel: types.optional(types.number()),
+  added: types.optional(types.string()),
+  bucket: types.optional(types.string()),
+  date: types.optional(types.string()),
+  description: types.optional(types.string()),
+  instore: types.optional(types.boolean()),
+  keyvalues: types.optional(z.any()),
+  media: types.optional(types.number()),
+  name: types.optional(types.string()),
+  owner: types.optional(types.string()),
+  relations: types.optional(z.any()),
+  simhash: types.optional(types.number()),
+  size: types.optional(types.number()),
+  storageid: types.optional(types.string()),
+  systemid: types.optional(types.string()),
+  tags: types.optional(z.array(z.lazy(() => Tag$inboundSchema))),
+  type: types.optional(types.number()),
+  xscore: types.optional(types.number()),
+});
+
+export function itemFromJSON(
+  jsonString: string,
+): SafeParseResult<Item, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Item$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Item' from JSON`,
+  );
+}
+
+/** @internal */
+export const Identityportal$inboundSchema: z.ZodMiniType<
+  Identityportal,
+  unknown
+> = z.object({
+  linea: types.string(),
+  item: types.optional(z.lazy(() => Item$inboundSchema)),
+  lineraw: types.optional(types.string()),
+  linesafterraw: z.optional(z.nullable(types.string())),
+  linesbeforeraw: z.optional(z.nullable(types.string())),
+  positionabsolute: types.optional(types.number()),
+  positionline: types.optional(types.number()),
+  positionsize: types.optional(types.number()),
+});
+
+export function identityportalFromJSON(
+  jsonString: string,
+): SafeParseResult<Identityportal, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Identityportal$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Identityportal' from JSON`,
+  );
+}
+
+/** @internal */
+export const Intelligencex$inboundSchema: z.ZodMiniType<
+  Intelligencex,
+  unknown
+> = z.object({
+  identityportal: types.optional(
+    z.array(z.lazy(() => Identityportal$inboundSchema)),
+  ),
+});
+
+export function intelligencexFromJSON(
+  jsonString: string,
+): SafeParseResult<Intelligencex, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Intelligencex$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Intelligencex' from JSON`,
+  );
+}
+
+/** @internal */
+export const Compilation$inboundSchema: z.ZodMiniType<Compilation, unknown> =
+  openEnums.inboundSchema(Compilation);
+
+/** @internal */
+export const Passwordless$inboundSchema: z.ZodMiniType<Passwordless, unknown> =
+  openEnums.inboundSchema(Passwordless);
+
+/** @internal */
+export const Unverified$inboundSchema: z.ZodMiniType<Unverified, unknown> =
+  openEnums.inboundSchema(Unverified);
+
+/** @internal */
+export const ResultSource$inboundSchema: z.ZodMiniType<ResultSource, unknown> =
+  z.pipe(
+    z.object({
+      breach_date: types.string(),
+      compilation: Compilation$inboundSchema,
+      name: types.string(),
+      passwordless: Passwordless$inboundSchema,
+      unverified: Unverified$inboundSchema,
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "breach_date": "breachDate",
+      });
+    }),
+  );
+
+export function resultSourceFromJSON(
+  jsonString: string,
+): SafeParseResult<ResultSource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResultSource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResultSource' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesResult$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesResult,
+  unknown
+> = z.pipe(
+  z.object({
+    address: types.nullable(types.string()),
+    country: types.nullable(types.string()),
+    dob: types.nullable(types.string()),
+    email: types.nullable(types.string()),
+    fields: z.array(types.string()),
+    first_name: types.nullable(types.string()),
+    last_name: types.nullable(types.string()),
+    name: types.nullable(types.string()),
+    password: types.nullable(types.string()),
+    phone: types.nullable(types.string()),
+    source: z.lazy(() => ResultSource$inboundSchema),
+    state: types.nullable(types.string()),
+    zip: types.nullable(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "first_name": "firstName",
+      "last_name": "lastName",
+    });
+  }),
+);
+
+export function searchWebDatabasesResultFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesResult' from JSON`,
+  );
+}
+
+/** @internal */
+export const Leakcheck$inboundSchema: z.ZodMiniType<Leakcheck, unknown> = z
+  .object({
+    error: types.nullable(types.string()),
+    found: types.number(),
+    quota: types.nullable(types.number()),
+    result: z.array(z.lazy(() => SearchWebDatabasesResult$inboundSchema)),
+    success: types.boolean(),
+  });
+
+export function leakcheckFromJSON(
+  jsonString: string,
+): SafeParseResult<Leakcheck, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Leakcheck$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Leakcheck' from JSON`,
+  );
+}
+
+/** @internal */
+export const Datum$inboundSchema: z.ZodMiniType<Datum, unknown> = z.pipe(
+  collectExtraKeys$(
+    z.catchall(
+      z.object({
+        Email: types.optional(types.string()),
+        NickName: types.optional(types.string()),
+        Password: types.optional(types.string()),
+        Url: types.optional(types.string()),
+      }),
+      types.string(),
+    ),
+    "additionalProperties",
+    true,
+  ),
+  z.transform((v) => {
+    return remap$(v, {
+      "Email": "email",
+      "NickName": "nickName",
+      "Password": "password",
+      "Url": "url",
+    });
+  }),
+);
+
+export function datumFromJSON(
+  jsonString: string,
+): SafeParseResult<Datum, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Datum$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Datum' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesList$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesList,
+  unknown
+> = z.pipe(
+  z.object({
+    Data: z.array(z.lazy(() => Datum$inboundSchema)),
+    InfoLeak: types.string(),
+    NumOfResults: types.number(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "Data": "data",
+      "InfoLeak": "infoLeak",
+      "NumOfResults": "numOfResults",
+    });
+  }),
+);
+
+export function searchWebDatabasesListFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesList' from JSON`,
+  );
+}
+
+/** @internal */
+export const Leakosint$inboundSchema: z.ZodMiniType<Leakosint, unknown> = z
+  .pipe(
+    z.object({
+      List: z.record(
+        z.string(),
+        z.lazy(() => SearchWebDatabasesList$inboundSchema),
+      ),
+      NumOfDatabase: types.number(),
+      NumOfResults: types.number(),
+      price: types.number(),
+      "search time": types.number(),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "List": "list",
+        "NumOfDatabase": "numOfDatabase",
+        "NumOfResults": "numOfResults",
+        "search time": "searchTime",
+      });
+    }),
+  );
+
+export function leakosintFromJSON(
+  jsonString: string,
+): SafeParseResult<Leakosint, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Leakosint$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Leakosint' from JSON`,
+  );
+}
+
+/** @internal */
+export const Body$inboundSchema: z.ZodMiniType<Body, unknown> = z.pipe(
+  collectExtraKeys$(
+    z.catchall(
+      z.object({
+        Bio: types.optional(types.string()),
+      }),
+      types.string(),
+    ),
+    "additionalProperties",
+    true,
+  ),
+  z.transform((v) => {
+    return remap$(v, {
+      "Bio": "bio",
+    });
+  }),
+);
+
+export function bodyFromJSON(
+  jsonString: string,
+): SafeParseResult<Body, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Body$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Body' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesTimeline$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesTimeline,
+  unknown
+> = z.pipe(
+  z.object({
+    group_items: z.record(z.string(), z.any()),
+    group_years: z.record(z.string(), z.any()),
+    groups: z.record(z.string(), z.any()),
+    last_seen: types.boolean(),
+    last_seen_date: types.nullable(types.string()),
+    registered: types.boolean(),
+    registered_date: types.nullable(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "group_items": "groupItems",
+      "group_years": "groupYears",
+      "last_seen": "lastSeen",
+      "last_seen_date": "lastSeenDate",
+      "registered_date": "registeredDate",
+    });
+  }),
+);
+
+export function searchWebDatabasesTimelineFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesTimeline, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesTimeline$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesTimeline' from JSON`,
+  );
+}
+
+/** @internal */
+export const FrontSchema$inboundSchema: z.ZodMiniType<FrontSchema, unknown> = z
+  .object({
+    body: z.lazy(() => Body$inboundSchema),
+    image: types.string(),
+    module: types.string(),
+    tags: z.array(types.string()),
+    timeline: z.lazy(() => SearchWebDatabasesTimeline$inboundSchema),
+  });
+
+export function frontSchemaFromJSON(
+  jsonString: string,
+): SafeParseResult<FrontSchema, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FrontSchema$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FrontSchema' from JSON`,
+  );
+}
+
+/** @internal */
+export const Bio$inboundSchema: z.ZodMiniType<Bio, unknown> = z.pipe(
+  z.object({
+    proper_key: types.string(),
+    type: types.literal("str"),
+    value: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function bioFromJSON(
+  jsonString: string,
+): SafeParseResult<Bio, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Bio$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Bio' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesId$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesId,
+  unknown
+> = z.pipe(
+  z.object({
+    proper_key: types.string(),
+    type: types.literal("str"),
+    value: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function searchWebDatabasesIdFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesId' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesLocation$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesLocation,
+  unknown
+> = z.pipe(
+  z.object({
+    proper_key: types.string(),
+    type: types.literal("str"),
+    value: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function searchWebDatabasesLocationFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesLocation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesLocation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesLocation' from JSON`,
+  );
+}
+
+/** @internal */
+export const Name$inboundSchema: z.ZodMiniType<Name, unknown> = z.pipe(
+  z.object({
+    proper_key: types.string(),
+    type: types.literal("str"),
+    value: types.string(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function nameFromJSON(
+  jsonString: string,
+): SafeParseResult<Name, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Name$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Name' from JSON`,
+  );
+}
+
+/** @internal */
+export const PictureUrl$inboundSchema: z.ZodMiniType<PictureUrl, unknown> = z
+  .pipe(
+    z.object({
+      proper_key: types.string(),
+      type: types.literal("str"),
+      value: types.string(),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "proper_key": "properKey",
+      });
+    }),
+  );
+
+export function pictureUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<PictureUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PictureUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PictureUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlatformVariableType$inboundSchema: z.ZodMiniType<
+  PlatformVariableType,
+  unknown
+> = openEnums.inboundSchema(PlatformVariableType);
+
+/** @internal */
+export const Value$inboundSchema: z.ZodMiniType<Value, unknown> = z.object({
+  url: types.string(),
+});
+
+export function valueFromJSON(
+  jsonString: string,
+): SafeParseResult<Value, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Value$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Value' from JSON`,
+  );
+}
+
+/** @internal */
+export const ValueUnion$inboundSchema: z.ZodMiniType<ValueUnion, unknown> =
+  smartUnion([
+    types.number(),
+    types.string(),
+    z.array(z.lazy(() => Value$inboundSchema)),
+    types.boolean(),
+  ]);
+
+export function valueUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<ValueUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ValueUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ValueUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const PlatformVariable$inboundSchema: z.ZodMiniType<
+  PlatformVariable,
+  unknown
+> = z.pipe(
+  z.object({
+    key: types.string(),
+    proper_key: types.string(),
+    type: PlatformVariableType$inboundSchema,
+    value: smartUnion([
+      types.number(),
+      types.string(),
+      z.array(z.lazy(() => Value$inboundSchema)),
+      types.boolean(),
+    ]),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function platformVariableFromJSON(
+  jsonString: string,
+): SafeParseResult<PlatformVariable, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PlatformVariable$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PlatformVariable' from JSON`,
+  );
+}
+
+/** @internal */
+export const Private$inboundSchema: z.ZodMiniType<Private, unknown> = z.pipe(
+  z.object({
+    proper_key: types.string(),
+    type: types.literal("bool"),
+    value: types.boolean(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function privateFromJSON(
+  jsonString: string,
+): SafeParseResult<Private, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Private$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Private' from JSON`,
+  );
+}
+
+/** @internal */
+export const ProfileUrl$inboundSchema: z.ZodMiniType<ProfileUrl, unknown> = z
+  .pipe(
+    z.object({
+      proper_key: types.string(),
+      type: types.literal("str"),
+      value: types.string(),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "proper_key": "properKey",
+      });
+    }),
+  );
+
+export function profileUrlFromJSON(
+  jsonString: string,
+): SafeParseResult<ProfileUrl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProfileUrl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProfileUrl' from JSON`,
+  );
+}
+
+/** @internal */
+export const Registered$inboundSchema: z.ZodMiniType<Registered, unknown> = z
+  .pipe(
+    z.object({
+      proper_key: types.string(),
+      type: types.literal("bool"),
+      value: types.boolean(),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "proper_key": "properKey",
+      });
+    }),
+  );
+
+export function registeredFromJSON(
+  jsonString: string,
+): SafeParseResult<Registered, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Registered$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Registered' from JSON`,
+  );
+}
+
+/** @internal */
+export const Verified$inboundSchema: z.ZodMiniType<Verified, unknown> = z.pipe(
+  z.object({
+    proper_key: types.string(),
+    type: types.literal("bool"),
+    value: types.boolean(),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "proper_key": "properKey",
+    });
+  }),
+);
+
+export function verifiedFromJSON(
+  jsonString: string,
+): SafeParseResult<Verified, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Verified$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Verified' from JSON`,
+  );
+}
+
+/** @internal */
+export const SpecFormat$inboundSchema: z.ZodMiniType<SpecFormat, unknown> = z
+  .pipe(
+    z.object({
+      bio: types.optional(z.lazy(() => Bio$inboundSchema)),
+      id: types.optional(z.lazy(() => SearchWebDatabasesId$inboundSchema)),
+      location: types.optional(
+        z.lazy(() => SearchWebDatabasesLocation$inboundSchema),
+      ),
+      name: types.optional(z.lazy(() => Name$inboundSchema)),
+      picture_url: types.optional(z.lazy(() => PictureUrl$inboundSchema)),
+      platform_variables: types.optional(
+        z.array(z.lazy(() => PlatformVariable$inboundSchema)),
+      ),
+      private: types.optional(z.lazy(() => Private$inboundSchema)),
+      profile_url: types.optional(z.lazy(() => ProfileUrl$inboundSchema)),
+      registered: types.optional(z.lazy(() => Registered$inboundSchema)),
+      verified: types.optional(z.lazy(() => Verified$inboundSchema)),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "picture_url": "pictureUrl",
+        "platform_variables": "platformVariables",
+        "profile_url": "profileUrl",
+      });
+    }),
+  );
+
+export function specFormatFromJSON(
+  jsonString: string,
+): SafeParseResult<SpecFormat, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SpecFormat$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SpecFormat' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesStatus$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesStatus,
+  unknown
+> = openEnums.inboundSchema(SearchWebDatabasesStatus);
+
+/** @internal */
+export const Category$inboundSchema: z.ZodMiniType<Category, unknown> = z
+  .object({
+    name: types.string(),
+  });
+
+export function categoryFromJSON(
+  jsonString: string,
+): SafeParseResult<Category, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Category$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Category' from JSON`,
+  );
+}
+
+/** @internal */
+export const Osintindustry$inboundSchema: z.ZodMiniType<
+  Osintindustry,
+  unknown
+> = z.pipe(
+  z.object({
+    data: z.record(z.string(), z.any()),
+    front_schemas: z.array(z.lazy(() => FrontSchema$inboundSchema)),
+    module: types.string(),
+    reliable_source: types.boolean(),
+    spec_format: z.array(z.lazy(() => SpecFormat$inboundSchema)),
+    status: SearchWebDatabasesStatus$inboundSchema,
+    category: types.optional(z.lazy(() => Category$inboundSchema)),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "front_schemas": "frontSchemas",
+      "reliable_source": "reliableSource",
+      "spec_format": "specFormat",
+    });
+  }),
+);
+
+export function osintindustryFromJSON(
+  jsonString: string,
+): SafeParseResult<Osintindustry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Osintindustry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Osintindustry' from JSON`,
+  );
+}
+
+/** @internal */
+export const Snusbase$inboundSchema: z.ZodMiniType<Snusbase, unknown> = z
+  .object({
+    address: types.optional(types.string()),
+    birthdate: types.optional(types.string()),
+    city: types.optional(types.string()),
+    company: types.optional(types.string()),
+    country: types.optional(types.string()),
+    created: types.optional(types.string()),
+    date: types.optional(types.string()),
+    domain: types.optional(types.string()),
+    email: types.optional(types.string()),
+    followers: types.optional(types.string()),
+    gender: types.optional(types.string()),
+    hash: types.optional(types.string()),
+    host: types.optional(types.string()),
+    id: types.optional(types.string()),
+    job: types.optional(types.string()),
+    language: types.optional(types.string()),
+    lastip: types.optional(types.string()),
+    name: types.optional(types.string()),
+    other: types.optional(types.string()),
+    password: types.optional(types.string()),
+    phone: types.optional(types.string()),
+    regip: types.optional(types.string()),
+    salt: types.optional(types.string()),
+    state: types.optional(types.string()),
+    uid: types.optional(types.string()),
+    unparsed: types.optional(types.string()),
+    updated: types.optional(types.string()),
+    url: types.optional(types.string()),
+    username: types.optional(types.string()),
+    zip: types.optional(types.string()),
+  });
+
+export function snusbaseFromJSON(
+  jsonString: string,
+): SafeParseResult<Snusbase, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Snusbase$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Snusbase' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseT$inboundSchema: z.ZodMiniType<ResponseT, unknown> = z
+  .object({
+    cloudsint: types.optional(z.lazy(() => Cloudsint$inboundSchema)),
+    ghosint: types.optional(z.lazy(() => Ghosint$inboundSchema)),
+    hackcheck: types.optional(z.lazy(() => Hackcheck$inboundSchema)),
+    intelligencex: types.optional(z.lazy(() => Intelligencex$inboundSchema)),
+    leakcheck: types.optional(z.lazy(() => Leakcheck$inboundSchema)),
+    leakosint: types.optional(z.lazy(() => Leakosint$inboundSchema)),
+    osintindustries: types.optional(
+      z.array(z.lazy(() => Osintindustry$inboundSchema)),
+    ),
+    snusbase: types.optional(
+      z.record(z.string(), z.array(z.lazy(() => Snusbase$inboundSchema))),
+    ),
+  });
+
+export function responseFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseT' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWebDatabasesResponse$inboundSchema: z.ZodMiniType<
+  SearchWebDatabasesResponse,
+  unknown
+> = z.object({
+  response: z.lazy(() => ResponseT$inboundSchema),
+  success: types.boolean(),
+  error: types.optional(types.string()),
+});
+
+export function searchWebDatabasesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWebDatabasesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWebDatabasesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWebDatabasesResponse' from JSON`,
+  );
+}