@indiciaosint/sdk 1.0.1 → 1.1.0

package/src/models/operations/search-shodan.ts

@@ -0,0 +1,653 @@
+/*
+ * 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 { 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 type SearchShodanRequest = {
+  query: string;
+};
+
+export type Components = {
+  categories?: Array<string> | undefined;
+  confidence?: number | undefined;
+  versions?: Array<string> | undefined;
+};
+
+export type Favicon = {
+  data?: string | undefined;
+  location?: string | undefined;
+};
+
+export type Redirect = {
+  data?: string | undefined;
+  host?: string | undefined;
+  location?: string | undefined;
+};
+
+export type Http = {
+  components?: { [k: string]: Components } | undefined;
+  favicon?: Favicon | undefined;
+  host?: string | null | undefined;
+  html?: string | null | undefined;
+  location?: string | undefined;
+  redirects?: Array<Redirect> | undefined;
+  robots?: string | null | undefined;
+  server?: string | null | undefined;
+  title?: string | null | undefined;
+};
+
+export type SearchShodanLocation = {
+  city?: string | undefined;
+  countryCode?: string | undefined;
+  countryName?: string | undefined;
+  dmaCode?: number | undefined;
+  latitude?: number | undefined;
+  longitude?: number | undefined;
+  regionCode?: string | undefined;
+};
+
+export type Kex = {
+  compressionAlgorithms?: Array<string> | undefined;
+  encryptionAlgorithms?: Array<string> | undefined;
+  kexAlgorithms?: Array<string> | undefined;
+  keyFollows?: boolean | undefined;
+  languages?: Array<string> | undefined;
+  macAlgorithms?: Array<string> | undefined;
+  serverHostKeyAlgorithms?: Array<string> | undefined;
+  unused?: number | undefined;
+};
+
+export type Ssh = {
+  cipher?: string | undefined;
+  fingerprint?: string | undefined;
+  hassh?: string | undefined;
+  kex?: Kex | undefined;
+  key?: string | undefined;
+  mac?: string | undefined;
+  type?: string | undefined;
+};
+
+export type Extension = {
+  critical?: boolean | undefined;
+  data?: string | undefined;
+  name?: string | undefined;
+};
+
+export type Issuer = {
+  c?: string | undefined;
+  cn?: string | undefined;
+  o?: string | undefined;
+};
+
+export type Pubkey = {
+  bits?: number | undefined;
+  type?: string | undefined;
+};
+
+export type Subject = {
+  cn?: string | undefined;
+};
+
+export type Cert = {
+  expired?: boolean | undefined;
+  expires?: string | undefined;
+  extensions?: Array<Extension> | undefined;
+  fingerprint?: { [k: string]: string } | undefined;
+  issued?: string | undefined;
+  issuer?: Issuer | undefined;
+  pubkey?: Pubkey | undefined;
+  serial?: number | undefined;
+  sigAlg?: string | undefined;
+  subject?: Subject | undefined;
+  version?: number | undefined;
+};
+
+export type Cipher = {
+  bits?: number | undefined;
+  name?: string | undefined;
+  version?: string | undefined;
+};
+
+export type Tlstext = {
+  id?: number | undefined;
+  name?: string | undefined;
+};
+
+export type Trust = {
+  revoked?: boolean | undefined;
+};
+
+export type Versions = string | Array<string>;
+
+export type Ssl = {
+  acceptableCas?: Array<string> | undefined;
+  alpn?: Array<string> | undefined;
+  cert?: Cert | undefined;
+  chain?: Array<string> | undefined;
+  chainSha256?: Array<string> | undefined;
+  cipher?: Cipher | undefined;
+  handshakeStates?: Array<string> | undefined;
+  ja3s?: string | undefined;
+  jarm?: string | undefined;
+  tlstext?: Array<Tlstext> | undefined;
+  trust?: Trust | undefined;
+  versions?: string | Array<string> | undefined;
+};
+
+export type Match = {
+  asn?: string | undefined;
+  cpe?: Array<string> | undefined;
+  data?: string | undefined;
+  domains?: Array<string> | undefined;
+  hostnames?: Array<string> | undefined;
+  http?: Http | undefined;
+  ipStr?: string | undefined;
+  isp?: string | undefined;
+  location?: SearchShodanLocation | undefined;
+  org?: string | undefined;
+  os?: string | null | undefined;
+  port?: number | undefined;
+  product?: string | undefined;
+  ssh?: Ssh | undefined;
+  ssl?: Ssl | undefined;
+  timestamp?: string | undefined;
+  transport?: string | undefined;
+};
+
+export type SearchShodanData = {
+  matches: Array<Match>;
+  total: number;
+};
+
+/**
+ * Search successful
+ */
+export type SearchShodanResponse = {
+  data: SearchShodanData;
+  success: boolean;
+  error?: string | undefined;
+};
+
+/** @internal */
+export type SearchShodanRequest$Outbound = {
+  query: string;
+};
+
+/** @internal */
+export const SearchShodanRequest$outboundSchema: z.ZodMiniType<
+  SearchShodanRequest$Outbound,
+  SearchShodanRequest
+> = z.object({
+  query: z.string(),
+});
+
+export function searchShodanRequestToJSON(
+  searchShodanRequest: SearchShodanRequest,
+): string {
+  return JSON.stringify(
+    SearchShodanRequest$outboundSchema.parse(searchShodanRequest),
+  );
+}
+
+/** @internal */
+export const Components$inboundSchema: z.ZodMiniType<Components, unknown> = z
+  .object({
+    categories: types.optional(z.array(types.string())),
+    confidence: types.optional(types.number()),
+    versions: types.optional(z.array(types.string())),
+  });
+
+export function componentsFromJSON(
+  jsonString: string,
+): SafeParseResult<Components, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Components$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Components' from JSON`,
+  );
+}
+
+/** @internal */
+export const Favicon$inboundSchema: z.ZodMiniType<Favicon, unknown> = z.object({
+  data: types.optional(types.string()),
+  location: types.optional(types.string()),
+});
+
+export function faviconFromJSON(
+  jsonString: string,
+): SafeParseResult<Favicon, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Favicon$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Favicon' from JSON`,
+  );
+}
+
+/** @internal */
+export const Redirect$inboundSchema: z.ZodMiniType<Redirect, unknown> = z
+  .object({
+    data: types.optional(types.string()),
+    host: types.optional(types.string()),
+    location: types.optional(types.string()),
+  });
+
+export function redirectFromJSON(
+  jsonString: string,
+): SafeParseResult<Redirect, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Redirect$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Redirect' from JSON`,
+  );
+}
+
+/** @internal */
+export const Http$inboundSchema: z.ZodMiniType<Http, unknown> = z.object({
+  components: types.optional(
+    z.record(z.string(), z.lazy(() => Components$inboundSchema)),
+  ),
+  favicon: types.optional(z.lazy(() => Favicon$inboundSchema)),
+  host: z.optional(z.nullable(types.string())),
+  html: z.optional(z.nullable(types.string())),
+  location: types.optional(types.string()),
+  redirects: types.optional(z.array(z.lazy(() => Redirect$inboundSchema))),
+  robots: z.optional(z.nullable(types.string())),
+  server: z.optional(z.nullable(types.string())),
+  title: z.optional(z.nullable(types.string())),
+});
+
+export function httpFromJSON(
+  jsonString: string,
+): SafeParseResult<Http, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Http$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Http' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchShodanLocation$inboundSchema: z.ZodMiniType<
+  SearchShodanLocation,
+  unknown
+> = z.pipe(
+  z.object({
+    city: types.optional(types.string()),
+    country_code: types.optional(types.string()),
+    country_name: types.optional(types.string()),
+    dma_code: types.optional(types.number()),
+    latitude: types.optional(types.number()),
+    longitude: types.optional(types.number()),
+    region_code: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "country_code": "countryCode",
+      "country_name": "countryName",
+      "dma_code": "dmaCode",
+      "region_code": "regionCode",
+    });
+  }),
+);
+
+export function searchShodanLocationFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchShodanLocation, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchShodanLocation$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchShodanLocation' from JSON`,
+  );
+}
+
+/** @internal */
+export const Kex$inboundSchema: z.ZodMiniType<Kex, unknown> = z.pipe(
+  z.object({
+    compression_algorithms: types.optional(z.array(types.string())),
+    encryption_algorithms: types.optional(z.array(types.string())),
+    kex_algorithms: types.optional(z.array(types.string())),
+    key_follows: types.optional(types.boolean()),
+    languages: types.optional(z.array(types.string())),
+    mac_algorithms: types.optional(z.array(types.string())),
+    server_host_key_algorithms: types.optional(z.array(types.string())),
+    unused: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "compression_algorithms": "compressionAlgorithms",
+      "encryption_algorithms": "encryptionAlgorithms",
+      "kex_algorithms": "kexAlgorithms",
+      "key_follows": "keyFollows",
+      "mac_algorithms": "macAlgorithms",
+      "server_host_key_algorithms": "serverHostKeyAlgorithms",
+    });
+  }),
+);
+
+export function kexFromJSON(
+  jsonString: string,
+): SafeParseResult<Kex, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Kex$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Kex' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ssh$inboundSchema: z.ZodMiniType<Ssh, unknown> = z.object({
+  cipher: types.optional(types.string()),
+  fingerprint: types.optional(types.string()),
+  hassh: types.optional(types.string()),
+  kex: types.optional(z.lazy(() => Kex$inboundSchema)),
+  key: types.optional(types.string()),
+  mac: types.optional(types.string()),
+  type: types.optional(types.string()),
+});
+
+export function sshFromJSON(
+  jsonString: string,
+): SafeParseResult<Ssh, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ssh$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ssh' from JSON`,
+  );
+}
+
+/** @internal */
+export const Extension$inboundSchema: z.ZodMiniType<Extension, unknown> = z
+  .object({
+    critical: types.optional(types.boolean()),
+    data: types.optional(types.string()),
+    name: types.optional(types.string()),
+  });
+
+export function extensionFromJSON(
+  jsonString: string,
+): SafeParseResult<Extension, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Extension$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Extension' from JSON`,
+  );
+}
+
+/** @internal */
+export const Issuer$inboundSchema: z.ZodMiniType<Issuer, unknown> = z.pipe(
+  z.object({
+    C: types.optional(types.string()),
+    CN: types.optional(types.string()),
+    O: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "C": "c",
+      "CN": "cn",
+      "O": "o",
+    });
+  }),
+);
+
+export function issuerFromJSON(
+  jsonString: string,
+): SafeParseResult<Issuer, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Issuer$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Issuer' from JSON`,
+  );
+}
+
+/** @internal */
+export const Pubkey$inboundSchema: z.ZodMiniType<Pubkey, unknown> = z.object({
+  bits: types.optional(types.number()),
+  type: types.optional(types.string()),
+});
+
+export function pubkeyFromJSON(
+  jsonString: string,
+): SafeParseResult<Pubkey, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Pubkey$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Pubkey' from JSON`,
+  );
+}
+
+/** @internal */
+export const Subject$inboundSchema: z.ZodMiniType<Subject, unknown> = z.pipe(
+  z.object({
+    CN: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "CN": "cn",
+    });
+  }),
+);
+
+export function subjectFromJSON(
+  jsonString: string,
+): SafeParseResult<Subject, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Subject$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Subject' from JSON`,
+  );
+}
+
+/** @internal */
+export const Cert$inboundSchema: z.ZodMiniType<Cert, unknown> = z.pipe(
+  z.object({
+    expired: types.optional(types.boolean()),
+    expires: types.optional(types.string()),
+    extensions: types.optional(z.array(z.lazy(() => Extension$inboundSchema))),
+    fingerprint: types.optional(z.record(z.string(), types.string())),
+    issued: types.optional(types.string()),
+    issuer: types.optional(z.lazy(() => Issuer$inboundSchema)),
+    pubkey: types.optional(z.lazy(() => Pubkey$inboundSchema)),
+    serial: types.optional(types.number()),
+    sig_alg: types.optional(types.string()),
+    subject: types.optional(z.lazy(() => Subject$inboundSchema)),
+    version: types.optional(types.number()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "sig_alg": "sigAlg",
+    });
+  }),
+);
+
+export function certFromJSON(
+  jsonString: string,
+): SafeParseResult<Cert, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Cert$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Cert' from JSON`,
+  );
+}
+
+/** @internal */
+export const Cipher$inboundSchema: z.ZodMiniType<Cipher, unknown> = z.object({
+  bits: types.optional(types.number()),
+  name: types.optional(types.string()),
+  version: types.optional(types.string()),
+});
+
+export function cipherFromJSON(
+  jsonString: string,
+): SafeParseResult<Cipher, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Cipher$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Cipher' from JSON`,
+  );
+}
+
+/** @internal */
+export const Tlstext$inboundSchema: z.ZodMiniType<Tlstext, unknown> = z.object({
+  id: types.optional(types.number()),
+  name: types.optional(types.string()),
+});
+
+export function tlstextFromJSON(
+  jsonString: string,
+): SafeParseResult<Tlstext, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Tlstext$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Tlstext' from JSON`,
+  );
+}
+
+/** @internal */
+export const Trust$inboundSchema: z.ZodMiniType<Trust, unknown> = z.object({
+  revoked: types.optional(types.boolean()),
+});
+
+export function trustFromJSON(
+  jsonString: string,
+): SafeParseResult<Trust, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Trust$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Trust' from JSON`,
+  );
+}
+
+/** @internal */
+export const Versions$inboundSchema: z.ZodMiniType<Versions, unknown> =
+  smartUnion([types.string(), z.array(types.string())]);
+
+export function versionsFromJSON(
+  jsonString: string,
+): SafeParseResult<Versions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Versions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Versions' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ssl$inboundSchema: z.ZodMiniType<Ssl, unknown> = z.pipe(
+  z.object({
+    acceptable_cas: types.optional(z.array(types.string())),
+    alpn: types.optional(z.array(types.string())),
+    cert: types.optional(z.lazy(() => Cert$inboundSchema)),
+    chain: types.optional(z.array(types.string())),
+    chain_sha256: types.optional(z.array(types.string())),
+    cipher: types.optional(z.lazy(() => Cipher$inboundSchema)),
+    handshake_states: types.optional(z.array(types.string())),
+    ja3s: types.optional(types.string()),
+    jarm: types.optional(types.string()),
+    tlstext: types.optional(z.array(z.lazy(() => Tlstext$inboundSchema))),
+    trust: types.optional(z.lazy(() => Trust$inboundSchema)),
+    versions: types.optional(
+      smartUnion([types.string(), z.array(types.string())]),
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "acceptable_cas": "acceptableCas",
+      "chain_sha256": "chainSha256",
+      "handshake_states": "handshakeStates",
+    });
+  }),
+);
+
+export function sslFromJSON(
+  jsonString: string,
+): SafeParseResult<Ssl, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ssl$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ssl' from JSON`,
+  );
+}
+
+/** @internal */
+export const Match$inboundSchema: z.ZodMiniType<Match, unknown> = z.pipe(
+  z.object({
+    asn: types.optional(types.string()),
+    cpe: types.optional(z.array(types.string())),
+    data: types.optional(types.string()),
+    domains: types.optional(z.array(types.string())),
+    hostnames: types.optional(z.array(types.string())),
+    http: types.optional(z.lazy(() => Http$inboundSchema)),
+    ip_str: types.optional(types.string()),
+    isp: types.optional(types.string()),
+    location: types.optional(z.lazy(() => SearchShodanLocation$inboundSchema)),
+    org: types.optional(types.string()),
+    os: z.optional(z.nullable(types.string())),
+    port: types.optional(types.number()),
+    product: types.optional(types.string()),
+    ssh: types.optional(z.lazy(() => Ssh$inboundSchema)),
+    ssl: types.optional(z.lazy(() => Ssl$inboundSchema)),
+    timestamp: types.optional(types.string()),
+    transport: types.optional(types.string()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ip_str": "ipStr",
+    });
+  }),
+);
+
+export function matchFromJSON(
+  jsonString: string,
+): SafeParseResult<Match, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Match$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Match' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchShodanData$inboundSchema: z.ZodMiniType<
+  SearchShodanData,
+  unknown
+> = z.object({
+  matches: z.array(z.lazy(() => Match$inboundSchema)),
+  total: types.number(),
+});
+
+export function searchShodanDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchShodanData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchShodanData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchShodanData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchShodanResponse$inboundSchema: z.ZodMiniType<
+  SearchShodanResponse,
+  unknown
+> = z.object({
+  data: z.lazy(() => SearchShodanData$inboundSchema),
+  success: types.boolean(),
+  error: types.optional(types.string()),
+});
+
+export function searchShodanResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchShodanResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchShodanResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchShodanResponse' from JSON`,
+  );
+}