@indiciaosint/sdk 1.1.0 → 1.2.0

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

@@ -3,7 +3,12 @@
  */
 
 import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
 import { blobLikeSchema } from "../../types/blobs.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 SearchFaceMedia = {
   fileName: string;
@@ -17,6 +22,88 @@ export type SearchFaceRequest = {
   media: SearchFaceMedia | Blob;
 };
 
+export type DataError = {
+  status: "error";
+  success: false;
+  /**
+   * Human-readable error message.
+   */
+  error: string;
+};
+
+/**
+ * A data-only event indicating the search failed.
+ */
+export type SearchFaceErrorEvent = {
+  data: DataError;
+};
+
+export type SearchFaceResult = {
+  id: string;
+  hash: string;
+  group: number;
+  quality: number;
+  imageUrl: string;
+  /**
+   * Unix epoch milliseconds the source was crawled.
+   */
+  crawledAt: number;
+  sourceUrl: string;
+  thumbnailUrl: string;
+};
+
+/**
+ * Completed facial search result set.
+ */
+export type SearchFaceData = {
+  /**
+   * Time the search took, in seconds.
+   */
+  time: number;
+  /**
+   * Matched faces found across the internet.
+   */
+  results: Array<SearchFaceResult>;
+  /**
+   * Hash identifying this search.
+   */
+  searchHash: string;
+  /**
+   * Total number of matched faces.
+   */
+  numberOfResults: number;
+};
+
+/**
+ * Emitted as the `results` event with the completed matches.
+ */
+export type ResultsEvent = {
+  /**
+   * Completed facial search result set.
+   */
+  data: SearchFaceData;
+  event: "results";
+};
+
+/**
+ * Emitted as the `faces` event once detection completes.
+ */
+export type FacesEvent = {
+  /**
+   * Number of faces detected in the uploaded image, as a decimal string (5 credits charged per face). "0" means no face was detected.
+   */
+  data: string;
+  event: "faces";
+};
+
+/**
+ * A Server-Sent Event. The `event:` field names the type ("faces" or "results"); errors are delivered as a data-only event.
+ */
+export type FacialSearchEvent =
+  | FacesEvent
+  | ResultsEvent
+  | SearchFaceErrorEvent;
+
 /** @internal */
 export type SearchFaceMedia$Outbound = {
   fileName: string;
@@ -66,3 +153,175 @@ export function searchFaceRequestToJSON(
     SearchFaceRequest$outboundSchema.parse(searchFaceRequest),
   );
 }
+
+/** @internal */
+export const DataError$inboundSchema: z.ZodMiniType<DataError, unknown> = z
+  .object({
+    status: types.literal("error"),
+    success: types.literal(false),
+    error: types.string(),
+  });
+
+export function dataErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<DataError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataError' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchFaceErrorEvent$inboundSchema: z.ZodMiniType<
+  SearchFaceErrorEvent,
+  unknown
+> = z.object({
+  data: z.pipe(
+    z.pipe(
+      z.unknown(),
+      z.transform((v, ctx) => {
+        if (typeof v !== "string") return v;
+        try {
+          return JSON.parse(v);
+        } catch (err) {
+          ctx.issues.push({
+            input: v,
+            code: "custom",
+            message: `malformed json: ${err}`,
+          });
+          return z.NEVER;
+        }
+      }),
+    ),
+    z.lazy(() => DataError$inboundSchema),
+  ),
+});
+
+export function searchFaceErrorEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchFaceErrorEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchFaceErrorEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchFaceErrorEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchFaceResult$inboundSchema: z.ZodMiniType<
+  SearchFaceResult,
+  unknown
+> = z.object({
+  id: types.string(),
+  hash: types.string(),
+  group: types.number(),
+  quality: types.number(),
+  imageUrl: types.string(),
+  crawledAt: types.number(),
+  sourceUrl: types.string(),
+  thumbnailUrl: types.string(),
+});
+
+export function searchFaceResultFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchFaceResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchFaceResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchFaceResult' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchFaceData$inboundSchema: z.ZodMiniType<
+  SearchFaceData,
+  unknown
+> = z.object({
+  time: types.number(),
+  results: z.array(z.lazy(() => SearchFaceResult$inboundSchema)),
+  searchHash: types.string(),
+  numberOfResults: types.number(),
+});
+
+export function searchFaceDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchFaceData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchFaceData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchFaceData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResultsEvent$inboundSchema: z.ZodMiniType<ResultsEvent, unknown> =
+  z.object({
+    data: z.pipe(
+      z.pipe(
+        z.unknown(),
+        z.transform((v, ctx) => {
+          if (typeof v !== "string") return v;
+          try {
+            return JSON.parse(v);
+          } catch (err) {
+            ctx.issues.push({
+              input: v,
+              code: "custom",
+              message: `malformed json: ${err}`,
+            });
+            return z.NEVER;
+          }
+        }),
+      ),
+      z.lazy(() => SearchFaceData$inboundSchema),
+    ),
+    event: types.literal("results"),
+  });
+
+export function resultsEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ResultsEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResultsEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResultsEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const FacesEvent$inboundSchema: z.ZodMiniType<FacesEvent, unknown> = z
+  .object({
+    data: types.string(),
+    event: types.literal("faces"),
+  });
+
+export function facesEventFromJSON(
+  jsonString: string,
+): SafeParseResult<FacesEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FacesEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FacesEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const FacialSearchEvent$inboundSchema: z.ZodMiniType<
+  FacialSearchEvent,
+  unknown
+> = smartUnion([
+  z.lazy(() => FacesEvent$inboundSchema),
+  z.lazy(() => ResultsEvent$inboundSchema),
+  z.lazy(() => SearchFaceErrorEvent$inboundSchema),
+]);
+
+export function facialSearchEventFromJSON(
+  jsonString: string,
+): SafeParseResult<FacialSearchEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FacialSearchEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FacialSearchEvent' from JSON`,
+  );
+}

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

@@ -110,7 +110,7 @@ export type Socials = {
 
 export type SocialsUnion = Socials | Array<string>;
 
-export type Status = {
+export type SearchUsernameStatus = {
   isCoach?: boolean | undefined;
   isModerator?: boolean | undefined;
   isStaff?: boolean | undefined;
@@ -118,7 +118,7 @@ export type Status = {
   isTopBlogger?: boolean | undefined;
 };
 
-export type StatusUnion = string | Status;
+export type Status = string | SearchUsernameStatus;
 
 export type UrlEntity = {};
 
@@ -243,7 +243,7 @@ export type Metadata = {
     | Array<number | SocialLink | string | boolean | null>
     | undefined;
   socials?: Socials | Array<string> | undefined;
-  status?: string | Status | undefined;
+  status?: string | SearchUsernameStatus | undefined;
   steamId64?: string | undefined;
   streak?: number | undefined;
   subscriberCount?: number | undefined;
@@ -895,7 +895,10 @@ export function socialsUnionFromJSON(
 }
 
 /** @internal */
-export const Status$inboundSchema: z.ZodMiniType<Status, unknown> = z.pipe(
+export const SearchUsernameStatus$inboundSchema: z.ZodMiniType<
+  SearchUsernameStatus,
+  unknown
+> = z.pipe(
   z.object({
     is_coach: types.optional(types.boolean()),
     is_moderator: types.optional(types.boolean()),
@@ -914,27 +917,29 @@ export const Status$inboundSchema: z.ZodMiniType<Status, unknown> = z.pipe(
   }),
 );
 
-export function statusFromJSON(
+export function searchUsernameStatusFromJSON(
   jsonString: string,
-): SafeParseResult<Status, SDKValidationError> {
+): SafeParseResult<SearchUsernameStatus, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Status$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Status' from JSON`,
+    (x) => SearchUsernameStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchUsernameStatus' from JSON`,
   );
 }
 
 /** @internal */
-export const StatusUnion$inboundSchema: z.ZodMiniType<StatusUnion, unknown> =
-  smartUnion([types.string(), z.lazy(() => Status$inboundSchema)]);
+export const Status$inboundSchema: z.ZodMiniType<Status, unknown> = smartUnion([
+  types.string(),
+  z.lazy(() => SearchUsernameStatus$inboundSchema),
+]);
 
-export function statusUnionFromJSON(
+export function statusFromJSON(
   jsonString: string,
-): SafeParseResult<StatusUnion, SDKValidationError> {
+): SafeParseResult<Status, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => StatusUnion$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'StatusUnion' from JSON`,
+    (x) => Status$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Status' from JSON`,
   );
 }
 
@@ -1182,7 +1187,10 @@ export const Metadata$inboundSchema: z.ZodMiniType<Metadata, unknown> = z.pipe(
       ]),
     ),
     status: types.optional(
-      smartUnion([types.string(), z.lazy(() => Status$inboundSchema)]),
+      smartUnion([
+        types.string(),
+        z.lazy(() => SearchUsernameStatus$inboundSchema),
+      ]),
     ),
     steam_id_64: types.optional(types.string()),
     streak: types.optional(types.number()),

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,