@indiciaosint/sdk 0.0.1 → 1.0.1-patch

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

@@ -0,0 +1,632 @@
+/*
+ * 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 { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export type SearchShodanRequest = {
+  query: string;
+};
+
+export type SearchShodanLocation = {
+  city: string;
+  countryCode: string;
+  countryName: string;
+  dmaCode: number;
+  latitude: number;
+  longitude: number;
+  regionCode: string;
+};
+
+export type Components = {
+  categories?: Array<string> | undefined;
+  confidence?: number | undefined;
+  versions?: Array<string> | undefined;
+};
+
+export type Favicon = {
+  data: string;
+  location: string;
+};
+
+export type Redirect = {
+  data: string;
+  host: string;
+  location: string;
+};
+
+export type Http = {
+  components: { [k: string]: Components };
+  favicon: Favicon;
+  host: string;
+  html: string;
+  location: string;
+  redirects: Array<Redirect>;
+  robots: string;
+  server: string;
+  title: string;
+};
+
+export type Kex = {
+  compressionAlgorithms: Array<string>;
+  encryptionAlgorithms: Array<string>;
+  kexAlgorithms: Array<string>;
+  keyFollows: boolean;
+  languages: Array<string>;
+  macAlgorithms: Array<string>;
+  serverHostKeyAlgorithms: Array<string>;
+  unused: number;
+};
+
+export type Ssh = {
+  cipher: string;
+  fingerprint: string;
+  hassh: string;
+  kex: Kex;
+  key: string;
+  mac: string;
+  type: string;
+};
+
+export type Extension = {
+  data: string;
+  name: string;
+  critical?: boolean | undefined;
+};
+
+export type Issuer = {
+  c?: string | undefined;
+  cn?: string | undefined;
+  o?: string | undefined;
+};
+
+export type Pubkey = {
+  bits: number;
+  type: string;
+};
+
+export type Subject = {
+  cn?: string | undefined;
+};
+
+export type Cert = {
+  expired: boolean;
+  expires: string;
+  extensions: Array<Extension>;
+  fingerprint: { [k: string]: string };
+  issued: string;
+  issuer: Issuer;
+  pubkey: Pubkey;
+  serial: number;
+  sigAlg: string;
+  subject: Subject;
+  version: number;
+};
+
+export type Cipher = {
+  bits: number;
+  name: string;
+  version: string;
+};
+
+export type Tlstext = {
+  id: number;
+  name: string;
+};
+
+export type Trust = {
+  revoked: boolean;
+};
+
+export type Ssl = {
+  acceptableCas: Array<string>;
+  alpn: Array<string>;
+  cert: Cert;
+  chain: Array<string>;
+  chainSha256: Array<string>;
+  cipher: Cipher;
+  handshakeStates: Array<string>;
+  ja3s: string;
+  jarm: string;
+  tlstext: Array<Tlstext>;
+  trust: Trust;
+  versions: string;
+};
+
+export type Match = {
+  asn: string;
+  cpe: Array<string>;
+  data: string;
+  domains: Array<string>;
+  hostnames: Array<string>;
+  ipStr: string;
+  isp: string;
+  location: SearchShodanLocation;
+  org: string;
+  os: string;
+  port: number;
+  product: string;
+  timestamp: string;
+  transport: string;
+  http?: Http | undefined;
+  ssh?: Ssh | undefined;
+  ssl?: Ssl | 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 SearchShodanLocation$inboundSchema: z.ZodMiniType<
+  SearchShodanLocation,
+  unknown
+> = z.pipe(
+  z.object({
+    city: types.string(),
+    country_code: types.string(),
+    country_name: types.string(),
+    dma_code: types.number(),
+    latitude: types.number(),
+    longitude: types.number(),
+    region_code: 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 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.string(),
+  location: 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.string(),
+    host: types.string(),
+    location: 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: z.record(z.string(), z.lazy(() => Components$inboundSchema)),
+  favicon: z.lazy(() => Favicon$inboundSchema),
+  host: types.string(),
+  html: types.string(),
+  location: types.string(),
+  redirects: z.array(z.lazy(() => Redirect$inboundSchema)),
+  robots: types.string(),
+  server: types.string(),
+  title: 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 Kex$inboundSchema: z.ZodMiniType<Kex, unknown> = z.pipe(
+  z.object({
+    compression_algorithms: z.array(types.string()),
+    encryption_algorithms: z.array(types.string()),
+    kex_algorithms: z.array(types.string()),
+    key_follows: types.boolean(),
+    languages: z.array(types.string()),
+    mac_algorithms: z.array(types.string()),
+    server_host_key_algorithms: z.array(types.string()),
+    unused: 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.string(),
+  fingerprint: types.string(),
+  hassh: types.string(),
+  kex: z.lazy(() => Kex$inboundSchema),
+  key: types.string(),
+  mac: types.string(),
+  type: 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({
+    data: types.string(),
+    name: types.string(),
+    critical: types.optional(types.boolean()),
+  });
+
+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.number(),
+  type: 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.boolean(),
+    expires: types.string(),
+    extensions: z.array(z.lazy(() => Extension$inboundSchema)),
+    fingerprint: z.record(z.string(), types.string()),
+    issued: types.string(),
+    issuer: z.lazy(() => Issuer$inboundSchema),
+    pubkey: z.lazy(() => Pubkey$inboundSchema),
+    serial: types.number(),
+    sig_alg: types.string(),
+    subject: z.lazy(() => Subject$inboundSchema),
+    version: 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.number(),
+  name: types.string(),
+  version: 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.number(),
+  name: 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.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 Ssl$inboundSchema: z.ZodMiniType<Ssl, unknown> = z.pipe(
+  z.object({
+    acceptable_cas: z.array(types.string()),
+    alpn: z.array(types.string()),
+    cert: z.lazy(() => Cert$inboundSchema),
+    chain: z.array(types.string()),
+    chain_sha256: z.array(types.string()),
+    cipher: z.lazy(() => Cipher$inboundSchema),
+    handshake_states: z.array(types.string()),
+    ja3s: types.string(),
+    jarm: types.string(),
+    tlstext: z.array(z.lazy(() => Tlstext$inboundSchema)),
+    trust: z.lazy(() => Trust$inboundSchema),
+    versions: 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.string(),
+    cpe: z.array(types.string()),
+    data: types.string(),
+    domains: z.array(types.string()),
+    hostnames: z.array(types.string()),
+    ip_str: types.string(),
+    isp: types.string(),
+    location: z.lazy(() => SearchShodanLocation$inboundSchema),
+    org: types.string(),
+    os: types.string(),
+    port: types.number(),
+    product: types.string(),
+    timestamp: types.string(),
+    transport: types.string(),
+    http: types.optional(z.lazy(() => Http$inboundSchema)),
+    ssh: types.optional(z.lazy(() => Ssh$inboundSchema)),
+    ssl: types.optional(z.lazy(() => Ssl$inboundSchema)),
+  }),
+  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`,
+  );
+}