@indiciaosint/sdk 1.1.0 → 1.2.1

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 SearchFaceDataError = {
+  status: "error";
+  success: false;
+  /**
+   * Human-readable error message.
+   */
+  error: string;
+};
+
+/**
+ * A data-only event indicating the search failed.
+ */
+export type SearchFaceErrorEvent = {
+  data: SearchFaceDataError;
+};
+
+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,177 @@ export function searchFaceRequestToJSON(
     SearchFaceRequest$outboundSchema.parse(searchFaceRequest),
   );
 }
+
+/** @internal */
+export const SearchFaceDataError$inboundSchema: z.ZodMiniType<
+  SearchFaceDataError,
+  unknown
+> = z.object({
+  status: types.literal("error"),
+  success: types.literal(false),
+  error: types.string(),
+});
+
+export function searchFaceDataErrorFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchFaceDataError, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchFaceDataError$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchFaceDataError' 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(() => SearchFaceDataError$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-github.ts

@@ -7,6 +7,7 @@ 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 SearchGithubRequest = {
@@ -14,6 +15,25 @@ export type SearchGithubRequest = {
 };
 
 export type SearchGithubData = {
+  status: "error";
+  success: false;
+  /**
+   * Human-readable error message.
+   */
+  error: string;
+};
+
+/**
+ * A data-only event indicating the search failed.
+ */
+export type SearchGithubErrorEvent = {
+  data: SearchGithubData;
+};
+
+/**
+ * Completed GitHub profile, commit stats, and discovered emails.
+ */
+export type GithubInfo = {
   avatarUrl: string | null;
   bio: string | null;
   commitEmails: { [k: string]: Array<string> };
@@ -30,17 +50,54 @@ export type SearchGithubData = {
   publicGists: number;
   publicRepos: number;
   username: string;
+  /**
+   * Activity log id for this search, or null.
+   */
+  activityId?: string | null | undefined;
 };
 
 /**
- * Search successful
+ * Terminal `result` event with the completed GitHub profile.
  */
-export type SearchGithubResponse = {
-  data: SearchGithubData;
-  success: boolean;
-  error?: string | undefined;
+export type ResultEvent = {
+  /**
+   * Completed GitHub profile, commit stats, and discovered emails.
+   */
+  data: GithubInfo;
+  event: "result";
+};
+
+/**
+ * Keep-alive emitted roughly every 15s as the `heartbeat` event.
+ */
+export type HeartbeatEvent = {
+  /**
+   * Keep-alive heartbeat. Always an empty string.
+   */
+  data: string;
+  event: "heartbeat";
+};
+
+/**
+ * Progress update emitted as the `status` event.
+ */
+export type StatusEvent = {
+  /**
+   * Human-readable progress message (e.g. "Fetching commit history").
+   */
+  data: string;
+  event: "status";
 };
 
+/**
+ * A Server-Sent Event. The `event:` field names the type ("status", "heartbeat", or "result"); errors are delivered as a data-only event.
+ */
+export type GithubSearchEvent =
+  | StatusEvent
+  | HeartbeatEvent
+  | ResultEvent
+  | SearchGithubErrorEvent;
+
 /** @internal */
 export type SearchGithubRequest$Outbound = {
   query: string;
@@ -66,33 +123,11 @@ export function searchGithubRequestToJSON(
 export const SearchGithubData$inboundSchema: z.ZodMiniType<
   SearchGithubData,
   unknown
-> = z.pipe(
-  z.object({
-    avatar_url: types.nullable(types.string()),
-    bio: types.nullable(types.string()),
-    commitEmails: z.record(z.string(), z.array(types.string())),
-    commitRepoCount: types.number(),
-    commits: types.number(),
-    company: types.nullable(types.string()),
-    createdAt: types.nullable(types.string()),
-    followers: types.number(),
-    following: types.number(),
-    id: types.number(),
-    lastSeen: types.nullable(types.string()),
-    location: types.nullable(types.string()),
-    name: types.nullable(types.string()),
-    public_gists: types.number(),
-    public_repos: types.number(),
-    username: types.string(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "avatar_url": "avatarUrl",
-      "public_gists": "publicGists",
-      "public_repos": "publicRepos",
-    });
-  }),
-);
+> = z.object({
+  status: types.literal("error"),
+  success: types.literal(false),
+  error: types.string(),
+});
 
 export function searchGithubDataFromJSON(
   jsonString: string,
@@ -105,21 +140,170 @@ export function searchGithubDataFromJSON(
 }
 
 /** @internal */
-export const SearchGithubResponse$inboundSchema: z.ZodMiniType<
-  SearchGithubResponse,
+export const SearchGithubErrorEvent$inboundSchema: z.ZodMiniType<
+  SearchGithubErrorEvent,
+  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(() => SearchGithubData$inboundSchema),
+  ),
+});
+
+export function searchGithubErrorEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchGithubErrorEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchGithubErrorEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchGithubErrorEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const GithubInfo$inboundSchema: z.ZodMiniType<GithubInfo, unknown> = z
+  .pipe(
+    z.object({
+      avatar_url: types.nullable(types.string()),
+      bio: types.nullable(types.string()),
+      commitEmails: z.record(z.string(), z.array(types.string())),
+      commitRepoCount: types.number(),
+      commits: types.number(),
+      company: types.nullable(types.string()),
+      createdAt: types.nullable(types.string()),
+      followers: types.number(),
+      following: types.number(),
+      id: types.number(),
+      lastSeen: types.nullable(types.string()),
+      location: types.nullable(types.string()),
+      name: types.nullable(types.string()),
+      public_gists: types.number(),
+      public_repos: types.number(),
+      username: types.string(),
+      activityId: z.optional(z.nullable(types.string())),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "avatar_url": "avatarUrl",
+        "public_gists": "publicGists",
+        "public_repos": "publicRepos",
+      });
+    }),
+  );
+
+export function githubInfoFromJSON(
+  jsonString: string,
+): SafeParseResult<GithubInfo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GithubInfo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GithubInfo' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResultEvent$inboundSchema: z.ZodMiniType<ResultEvent, 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(() => GithubInfo$inboundSchema),
+    ),
+    event: types.literal("result"),
+  });
+
+export function resultEventFromJSON(
+  jsonString: string,
+): SafeParseResult<ResultEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResultEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResultEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const HeartbeatEvent$inboundSchema: z.ZodMiniType<
+  HeartbeatEvent,
   unknown
 > = z.object({
-  data: z.lazy(() => SearchGithubData$inboundSchema),
-  success: types.boolean(),
-  error: types.optional(types.string()),
+  data: types.string(),
+  event: types.literal("heartbeat"),
 });
 
-export function searchGithubResponseFromJSON(
+export function heartbeatEventFromJSON(
+  jsonString: string,
+): SafeParseResult<HeartbeatEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => HeartbeatEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'HeartbeatEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const StatusEvent$inboundSchema: z.ZodMiniType<StatusEvent, unknown> = z
+  .object({
+    data: types.string(),
+    event: types.literal("status"),
+  });
+
+export function statusEventFromJSON(
+  jsonString: string,
+): SafeParseResult<StatusEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => StatusEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StatusEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const GithubSearchEvent$inboundSchema: z.ZodMiniType<
+  GithubSearchEvent,
+  unknown
+> = smartUnion([
+  z.lazy(() => StatusEvent$inboundSchema),
+  z.lazy(() => HeartbeatEvent$inboundSchema),
+  z.lazy(() => ResultEvent$inboundSchema),
+  z.lazy(() => SearchGithubErrorEvent$inboundSchema),
+]);
+
+export function githubSearchEventFromJSON(
   jsonString: string,
-): SafeParseResult<SearchGithubResponse, SDKValidationError> {
+): SafeParseResult<GithubSearchEvent, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => SearchGithubResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'SearchGithubResponse' from JSON`,
+    (x) => GithubSearchEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GithubSearchEvent' from JSON`,
   );
 }