@indiciaosint/sdk 1.1.0 → 1.2.1

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

@@ -15,16 +15,17 @@ 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 = {
+export const SearchWebDatabasesService = {
   Cloudsint: "cloudsint",
   IntelligencexIdentityportal: "intelligencex.identityportal",
   Leakcheck: "leakcheck",
   Snusbase: "snusbase",
 } as const;
-export type Service = ClosedEnum<typeof Service>;
+export type SearchWebDatabasesService = ClosedEnum<
+  typeof SearchWebDatabasesService
+>;
 
 export const CloudsintType = {
-  Discordid: "discordid",
   Email: "email",
   Ip: "ip",
   Name: "name",
@@ -74,7 +75,7 @@ export type SnusbaseType = ClosedEnum<typeof SnusbaseType>;
 
 export type SearchWebDatabasesRequest = {
   query: string;
-  services: Array<Service>;
+  services: Array<SearchWebDatabasesService>;
   cloudsintType?: CloudsintType | undefined;
   intelxType?: IntelxType | undefined;
   leakCheckType?: LeakCheckType | undefined;
@@ -318,9 +319,9 @@ export type SearchWebDatabasesResponse = {
 };
 
 /** @internal */
-export const Service$outboundSchema: z.ZodMiniEnum<typeof Service> = z.enum(
-  Service,
-);
+export const SearchWebDatabasesService$outboundSchema: z.ZodMiniEnum<
+  typeof SearchWebDatabasesService
+> = z.enum(SearchWebDatabasesService);
 
 /** @internal */
 export const CloudsintType$outboundSchema: z.ZodMiniEnum<typeof CloudsintType> =
@@ -354,7 +355,7 @@ export const SearchWebDatabasesRequest$outboundSchema: z.ZodMiniType<
   SearchWebDatabasesRequest
 > = z.object({
   query: z.string(),
-  services: z.array(Service$outboundSchema),
+  services: z.array(SearchWebDatabasesService$outboundSchema),
   cloudsintType: z.optional(CloudsintType$outboundSchema),
   intelxType: z.optional(IntelxType$outboundSchema),
   leakCheckType: z.optional(LeakCheckType$outboundSchema),

package/src/models/security.ts

@@ -6,12 +6,12 @@ import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../lib/primitives.js";
 
 export type Security = {
-  apiKeyAuth?: string | undefined;
+  apiKey?: string | undefined;
 };
 
 /** @internal */
 export type Security$Outbound = {
-  ApiKeyAuth?: string | undefined;
+  ApiKey?: string | undefined;
 };
 
 /** @internal */
@@ -20,11 +20,11 @@ export const Security$outboundSchema: z.ZodMiniType<
   Security
 > = z.pipe(
   z.object({
-    apiKeyAuth: z.optional(z.string()),
+    apiKey: z.optional(z.string()),
   }),
   z.transform((v) => {
     return remap$(v, {
-      apiKeyAuth: "ApiKeyAuth",
+      apiKey: "ApiKey",
     });
   }),
 );

package/src/sdk/infrastructure.ts

@@ -8,6 +8,7 @@ import { infrastructureSearchDns } from "../funcs/infrastructure-search-dns.js";
 import { infrastructureSearchIpInfo } from "../funcs/infrastructure-search-ip-info.js";
 import { infrastructureSearchShodan } from "../funcs/infrastructure-search-shodan.js";
 import { infrastructureSearchWhois } from "../funcs/infrastructure-search-whois.js";
+import { EventStream } from "../lib/event-streams.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -86,137 +87,11 @@ export class Infrastructure extends ClientSDK {
    *
    * @remarks
    * Perform a port scan on a given IP address or domain.
-   *
-   *   Response type:
-   *   ```ts
-   *   interface NmapScanResult {
-   *     $: {
-   *       scanner: string;
-   *       args: string;
-   *       start: string;
-   *       startstr: string;
-   *       version: string;
-   *       xmloutputversion: string;
-   *     };
-   *     scaninfo: Array<{
-   *       $: {
-   *         type: string;
-   *         protocol: string;
-   *         numservices: string;
-   *         services: string;
-   *       };
-   *     }>;
-   *     verbose: Array<{ $: { level: string } }>;
-   *     debugging: Array<{ $: { level: string } }>;
-   *     taskprogress?: Array<{
-   *       $: {
-   *         task: string;
-   *         time: string;
-   *         percent: string;
-   *         remaining: string;
-   *         etc: string;
-   *       };
-   *     }>;
-   *     host?: Array<{
-   *       $: {
-   *         starttime: string;
-   *         endtime: string;
-   *       };
-   *       status: Array<{
-   *         $: {
-   *           state: string;
-   *           reason: string;
-   *           reason_ttl: string;
-   *         };
-   *       }>;
-   *       address: Array<{
-   *         $: {
-   *           addr: string;
-   *           addrtype: string;
-   *         };
-   *       }>;
-   *       hostnames?: Array<{
-   *         hostname: Array<{
-   *           $: {
-   *             name: string;
-   *             type: string;
-   *           };
-   *         }>;
-   *       }>;
-   *       ports?: Array<{
-   *         extraports?: Array<{
-   *           $: {
-   *             state: string;
-   *             count: string;
-   *           };
-   *           extrareasons: Array<{
-   *             $: {
-   *               reason: string;
-   *               count: string;
-   *               proto: string;
-   *               ports: string;
-   *             };
-   *           }>;
-   *         }>;
-   *         port?: Array<{
-   *           $: {
-   *             protocol: string;
-   *             portid: string;
-   *           };
-   *           state: Array<{
-   *             $: {
-   *               state: string;
-   *               reason: string;
-   *               reason_ttl: string;
-   *             };
-   *           }>;
-   *           service?: Array<{
-   *             $: {
-   *               name: string;
-   *               product?: string;
-   *               version?: string;
-   *               extrainfo?: string;
-   *               ostype?: string;
-   *               method: string;
-   *               conf: string;
-   *             };
-   *             cpe?: string[];
-   *           }>;
-   *         }>;
-   *       }>;
-   *       times?: Array<{
-   *         $: {
-   *           srtt: string;
-   *           rttvar: string;
-   *           to: string;
-   *         };
-   *       }>;
-   *     }>;
-   *     runstats: Array<{
-   *       finished: Array<{
-   *         $: {
-   *           time: string;
-   *           timestr: string;
-   *           summary: string;
-   *           elapsed: string;
-   *           exit: string;
-   *         };
-   *       }>;
-   *       hosts: Array<{
-   *         $: {
-   *           up: string;
-   *           down: string;
-   *           total: string;
-   *         };
-   *       }>;
-   *     }>;
-   *   }
-   * ```
    */
   async scanPorts(
     request: operations.ScanPortsRequest,
     options?: RequestOptions,
-  ): Promise<string> {
+  ): Promise<EventStream<operations.PortscanEvent>> {
     return unwrapAsync(infrastructureScanPorts(
       this,
       request,

package/src/sdk/intelligence.ts

@@ -12,6 +12,7 @@ import { intelligenceSearchPerson } from "../funcs/intelligence-search-person.js
 import { intelligenceSearchPhone } from "../funcs/intelligence-search-phone.js";
 import { intelligenceSearchSeon } from "../funcs/intelligence-search-seon.js";
 import { intelligenceSearchWebDatabases } from "../funcs/intelligence-search-web-databases.js";
+import { EventStream } from "../lib/event-streams.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -53,23 +54,11 @@ export class Intelligence extends ClientSDK {
    *
    * @remarks
    * Geolocate an image using AI-powered analysis. Streams progress updates via Server-Sent Events.
-   *
-   *       Response type:
-   *
-   *       ```ts
-   *       interface GeolocationResponse {
-   *         location: string | null;
-   *         coordinates: string | null;
-   *         certainty: string;
-   *         reasoning: string;
-   *         mapsUrl?: `https://www.google.com/maps/search/?api=1&query=${string}`;
-   *       }
-   *     ```
    */
   async geolocateMedia(
     request: operations.GeolocateMediaRequest,
     options?: RequestOptions,
-  ): Promise<string> {
+  ): Promise<EventStream<operations.GeolocationEvent>> {
     return unwrapAsync(intelligenceGeolocateMedia(
       this,
       request,
@@ -171,7 +160,7 @@ export class Intelligence extends ClientSDK {
   async searchFace(
     request: operations.SearchFaceRequest,
     options?: RequestOptions,
-  ): Promise<string> {
+  ): Promise<EventStream<operations.FacialSearchEvent>> {
     return unwrapAsync(intelligenceSearchFace(
       this,
       request,

package/src/sdk/socials.ts

@@ -7,6 +7,7 @@ import { socialsSearchGithub } from "../funcs/socials-search-github.js";
 import { socialsSearchRoblox } from "../funcs/socials-search-roblox.js";
 import { socialsSearchTiktok } from "../funcs/socials-search-tiktok.js";
 import { socialsSearchUsername } from "../funcs/socials-search-username.js";
+import { EventStream } from "../lib/event-streams.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -33,12 +34,12 @@ export class Socials extends ClientSDK {
    * GitHub Search
    *
    * @remarks
-   * Search GitHub profiles, info, and commit emails
+   * Search GitHub profiles, info, and commit emails. Streams progress updates via Server-Sent Events.
    */
   async searchGithub(
     request: operations.SearchGithubRequest,
     options?: RequestOptions,
-  ): Promise<operations.SearchGithubResponse> {
+  ): Promise<EventStream<operations.GithubSearchEvent>> {
     return unwrapAsync(socialsSearchGithub(
       this,
       request,
@@ -84,12 +85,12 @@ export class Socials extends ClientSDK {
    * Username Search V2
    *
    * @remarks
-   * Search various sites for a specific username
+   * Search various sites for a specific username. Streams progress updates via Server-Sent Events.
    */
   async searchUsername(
     request: operations.SearchUsernameRequest,
     options?: RequestOptions,
-  ): Promise<operations.SearchUsernameResponse> {
+  ): Promise<EventStream<operations.UsernameSearchEvent>> {
     return unwrapAsync(socialsSearchUsername(
       this,
       request,

package/src/types/discriminated-union.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { startCountingUnrecognized } from "./unrecognized.js";
+
+const UNKNOWN = Symbol("UNKNOWN");
+
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> =
+  & {
+    [K in Discriminator]: UnknownValue;
+  }
+  & {
+    raw: unknown;
+    isUnknown: true;
+  };
+
+export function isUnknown<Discriminator extends string>(
+  value: unknown,
+): value is Unknown<Discriminator> {
+  return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion<
+  InputDiscriminator extends string,
+  TOptions extends Readonly<Record<string, z.ZodMiniType>>,
+  UnknownValue extends string = "UNKNOWN",
+  OutputDiscriminator extends string = InputDiscriminator,
+>(
+  inputPropertyName: InputDiscriminator,
+  options: TOptions,
+  opts: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+  } = {},
+): z.ZodMiniType<
+  | z.output<TOptions[keyof TOptions]>
+  | Unknown<OutputDiscriminator, UnknownValue>,
+  unknown
+> {
+  const { unknownValue = "UNKNOWN" as UnknownValue, outputPropertyName } = opts;
+  return z.pipe(
+    z.unknown(),
+    z.transform((input) => {
+      const fallback = Object.defineProperties(
+        {
+          raw: input,
+          [outputPropertyName ?? inputPropertyName]: unknownValue,
+          isUnknown: true as const,
+        },
+        { [UNKNOWN]: { value: true, enumerable: false, configurable: false } },
+      );
+
+      const isObject = typeof input === "object" && input !== null;
+      if (!isObject) return fallback;
+
+      const discriminator = input[inputPropertyName as keyof typeof input];
+      if (typeof discriminator !== "string") return fallback;
+      if (!(discriminator in options)) return fallback;
+
+      const schema = options[discriminator];
+      if (!schema) return fallback;
+
+      // Start counters before parsing to track nested unrecognized/zeroDefault values
+      const unrecognizedCtr = startCountingUnrecognized();
+      const zeroDefaultCtr = startCountingDefaultToZeroValue();
+
+      const result = z.safeParse(schema, input);
+      if (!result.success) {
+        // Parse failed - don't propagate any counts from the failed attempt
+        unrecognizedCtr.end(0);
+        zeroDefaultCtr.end(0);
+        return fallback;
+      }
+
+      // Parse succeeded - propagate the actual counts
+      unrecognizedCtr.end();
+      zeroDefaultCtr.end();
+
+      if (outputPropertyName) {
+        (result.data as any)[outputPropertyName] = discriminator;
+      }
+
+      return result.data;
+    }),
+  ) as any;
+}

package/src/types/smart-union.ts

@@ -5,6 +5,7 @@
 // Not needed if lax mode
 import * as z from "zod/v4-mini";
 import { startCountingDefaultToZeroValue } from "./default-to-zero-value.js";
+import { isUnknown as isDiscriminatedUnionUnknown } from "./discriminated-union.js";
 import { RFCDate } from "./rfcdate.js";
 import { startCountingUnrecognized } from "./unrecognized.js";
 
@@ -118,7 +119,7 @@ function countFieldsRecursive(parsed: unknown): number {
 
   while (index < queue.length) {
     const value = queue[index++];
-    if (value === undefined) {
+    if (value === undefined || isDiscriminatedUnionUnknown(value)) {
       continue;
     }