@indiciaosint/sdk 1.0.1 → 1.0.3

package/src/models/operations/bypass-double-counter.ts

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+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 BypassDoubleCounterRequest = {
+  url: string;
+};
+
+/**
+ * Bypass successful
+ */
+export type BypassDoubleCounterResponse = {
+  success: boolean;
+  error?: string | undefined;
+};
+
+/** @internal */
+export type BypassDoubleCounterRequest$Outbound = {
+  url: string;
+};
+
+/** @internal */
+export const BypassDoubleCounterRequest$outboundSchema: z.ZodMiniType<
+  BypassDoubleCounterRequest$Outbound,
+  BypassDoubleCounterRequest
+> = z.object({
+  url: z.string(),
+});
+
+export function bypassDoubleCounterRequestToJSON(
+  bypassDoubleCounterRequest: BypassDoubleCounterRequest,
+): string {
+  return JSON.stringify(
+    BypassDoubleCounterRequest$outboundSchema.parse(bypassDoubleCounterRequest),
+  );
+}
+
+/** @internal */
+export const BypassDoubleCounterResponse$inboundSchema: z.ZodMiniType<
+  BypassDoubleCounterResponse,
+  unknown
+> = z.object({
+  success: types.boolean(),
+  error: types.optional(types.string()),
+});
+
+export function bypassDoubleCounterResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<BypassDoubleCounterResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BypassDoubleCounterResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BypassDoubleCounterResponse' from JSON`,
+  );
+}

package/src/models/operations/delete-activity.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type DeleteActivityRequest = {
+  /**
+   * a UUID
+   */
+  id: string;
+};
+
+/** @internal */
+export type DeleteActivityRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const DeleteActivityRequest$outboundSchema: z.ZodMiniType<
+  DeleteActivityRequest$Outbound,
+  DeleteActivityRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function deleteActivityRequestToJSON(
+  deleteActivityRequest: DeleteActivityRequest,
+): string {
+  return JSON.stringify(
+    DeleteActivityRequest$outboundSchema.parse(deleteActivityRequest),
+  );
+}

package/src/models/operations/download-intelx-file.ts

@@ -0,0 +1,157 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.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 RequestBody2 = {
+  bucket: "leaks.logs";
+  systemId: string;
+};
+
+export const Bucket = {
+  DarknetI2p: "darknet.i2p",
+  DarknetTor: "darknet.tor",
+  DocumentsPublicScihub: "documents.public.scihub",
+  Dumpster: "dumpster",
+  DumpsterWeb1: "dumpster.web.1",
+  DumpsterWebSsn: "dumpster.web.ssn",
+  LeaksLogs: "leaks.logs",
+  LeaksPrivateGeneral: "leaks.private.general",
+  LeaksPublicGeneral: "leaks.public.general",
+  LeaksPublicWikileaks: "leaks.public.wikileaks",
+  Pastes: "pastes",
+  PatentUs: "patent.us",
+  Usenet: "usenet",
+  WebGovRu: "web.gov.ru",
+  WebPublicAf: "web.public.af",
+  WebPublicAms: "web.public.ams",
+  WebPublicAq: "web.public.aq",
+  WebPublicBusiness: "web.public.business",
+  WebPublicCee: "web.public.cee",
+  WebPublicCn: "web.public.cn",
+  WebPublicCom: "web.public.com",
+  WebPublicDe: "web.public.de",
+  WebPublicEu: "web.public.eu",
+  WebPublicGov: "web.public.gov",
+  WebPublicInfo: "web.public.info",
+  WebPublicKp: "web.public.kp",
+  WebPublicMea: "web.public.mea",
+  WebPublicMisc: "web.public.misc",
+  WebPublicNet: "web.public.net",
+  WebPublicNord: "web.public.nord",
+  WebPublicOc: "web.public.oc",
+  WebPublicOrg: "web.public.org",
+  WebPublicPeer: "web.public.peer",
+  WebPublicRu: "web.public.ru",
+  WebPublicSocial: "web.public.social",
+  WebPublicTech: "web.public.tech",
+  WebPublicWe: "web.public.we",
+  Whois: "whois",
+} as const;
+export type Bucket = ClosedEnum<typeof Bucket>;
+
+export type RequestBody1 = {
+  bucket: Bucket;
+  storageId: string;
+};
+
+export type DownloadIntelxFileRequest = RequestBody1 | RequestBody2;
+
+/**
+ * Successful response
+ */
+export type DownloadIntelxFileResponse = {
+  success: boolean;
+  data?: string | undefined;
+};
+
+/** @internal */
+export type RequestBody2$Outbound = {
+  bucket: "leaks.logs";
+  systemId: string;
+};
+
+/** @internal */
+export const RequestBody2$outboundSchema: z.ZodMiniType<
+  RequestBody2$Outbound,
+  RequestBody2
+> = z.object({
+  bucket: z.literal("leaks.logs"),
+  systemId: z.string(),
+});
+
+export function requestBody2ToJSON(requestBody2: RequestBody2): string {
+  return JSON.stringify(RequestBody2$outboundSchema.parse(requestBody2));
+}
+
+/** @internal */
+export const Bucket$outboundSchema: z.ZodMiniEnum<typeof Bucket> = z.enum(
+  Bucket,
+);
+
+/** @internal */
+export type RequestBody1$Outbound = {
+  bucket: string;
+  storageId: string;
+};
+
+/** @internal */
+export const RequestBody1$outboundSchema: z.ZodMiniType<
+  RequestBody1$Outbound,
+  RequestBody1
+> = z.object({
+  bucket: Bucket$outboundSchema,
+  storageId: z.string(),
+});
+
+export function requestBody1ToJSON(requestBody1: RequestBody1): string {
+  return JSON.stringify(RequestBody1$outboundSchema.parse(requestBody1));
+}
+
+/** @internal */
+export type DownloadIntelxFileRequest$Outbound =
+  | RequestBody1$Outbound
+  | RequestBody2$Outbound;
+
+/** @internal */
+export const DownloadIntelxFileRequest$outboundSchema: z.ZodMiniType<
+  DownloadIntelxFileRequest$Outbound,
+  DownloadIntelxFileRequest
+> = smartUnion([
+  z.lazy(() => RequestBody1$outboundSchema),
+  z.lazy(() => RequestBody2$outboundSchema),
+]);
+
+export function downloadIntelxFileRequestToJSON(
+  downloadIntelxFileRequest: DownloadIntelxFileRequest,
+): string {
+  return JSON.stringify(
+    DownloadIntelxFileRequest$outboundSchema.parse(downloadIntelxFileRequest),
+  );
+}
+
+/** @internal */
+export const DownloadIntelxFileResponse$inboundSchema: z.ZodMiniType<
+  DownloadIntelxFileResponse,
+  unknown
+> = z.object({
+  success: types.boolean(),
+  data: types.optional(types.string()),
+});
+
+export function downloadIntelxFileResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DownloadIntelxFileResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DownloadIntelxFileResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DownloadIntelxFileResponse' from JSON`,
+  );
+}

package/src/models/operations/geolocate-media.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const Model = {
+  Default: "default",
+  Enhanced: "enhanced",
+} as const;
+export type Model = ClosedEnum<typeof Model>;
+
+export type GeolocateMediaRequest = {
+  media: any;
+  locationHint?: string | undefined;
+  model?: Model | undefined;
+};
+
+/** @internal */
+export const Model$outboundSchema: z.ZodMiniEnum<typeof Model> = z.enum(Model);
+
+/** @internal */
+export type GeolocateMediaRequest$Outbound = {
+  media: any;
+  locationHint?: string | undefined;
+  model?: string | undefined;
+};
+
+/** @internal */
+export const GeolocateMediaRequest$outboundSchema: z.ZodMiniType<
+  GeolocateMediaRequest$Outbound,
+  GeolocateMediaRequest
+> = z.object({
+  media: z.any(),
+  locationHint: z.optional(z.string()),
+  model: z.optional(Model$outboundSchema),
+});
+
+export function geolocateMediaRequestToJSON(
+  geolocateMediaRequest: GeolocateMediaRequest,
+): string {
+  return JSON.stringify(
+    GeolocateMediaRequest$outboundSchema.parse(geolocateMediaRequest),
+  );
+}

package/src/models/operations/get-activity.ts

@@ -0,0 +1,218 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.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 GetActivityRequest = {
+  /**
+   * a UUID
+   */
+  id: string;
+};
+
+export type GetActivityResult = {};
+
+export type GetActivityResultUnion =
+  | number
+  | GetActivityResult
+  | string
+  | boolean;
+
+export const GetActivityType = {
+  Address: "address",
+  Breachvip: "breachvip",
+  Certificates: "certificates",
+  Cloudsint: "cloudsint",
+  Courtrecords: "courtrecords",
+  Discord: "discord",
+  Dnsdumpster: "dnsdumpster",
+  Doogle: "doogle",
+  Doublecounter: "doublecounter",
+  Email: "email",
+  Fr: "fr",
+  Geolocation: "geolocation",
+  GhosintSearch: "ghosint.search",
+  Github: "github",
+  Gmail: "gmail",
+  Hudsonrock: "hudsonrock",
+  IntelligencexIdentityportal: "intelligencex.identityportal",
+  Intelx: "intelx",
+  IntelxStealerlogs: "intelx.stealerlogs",
+  Ipinfo: "ipinfo",
+  Leakcheck: "leakcheck",
+  Leakosint: "leakosint",
+  Melissa: "melissa",
+  Minecraft: "minecraft",
+  Osintindustries: "osintindustries",
+  Other: "other",
+  Person: "person",
+  Phone: "phone",
+  Phonebook: "phonebook",
+  Pimeyes: "pimeyes",
+  Portscan: "portscan",
+  Roblox: "roblox",
+  Scraper: "scraper",
+  Seon: "seon",
+  Shodan: "shodan",
+  Snusbase: "snusbase",
+  Tiktok: "tiktok",
+  Uk: "uk",
+  Username: "username",
+  Usernames: "usernames",
+  Vehicle: "vehicle",
+  WebDbs: "web-dbs",
+  Whois: "whois",
+} as const;
+export type GetActivityType = OpenEnum<typeof GetActivityType>;
+
+export type GetActivityActivity = {
+  agent: boolean | null;
+  apiKey: string | null;
+  case: string | null;
+  detail: string;
+  /**
+   * a RFC-4122-compliant UUID
+   */
+  id: string;
+  query: string;
+  result: number | GetActivityResult | string | boolean | null;
+  /**
+   * an integer representing a safe Unix timestamp
+   */
+  time: number;
+  type: GetActivityType;
+  user: string | null;
+};
+
+/**
+ * Successful response with the activity details.
+ */
+export type GetActivityResponse = {
+  activity: GetActivityActivity;
+  success: boolean;
+};
+
+/** @internal */
+export type GetActivityRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const GetActivityRequest$outboundSchema: z.ZodMiniType<
+  GetActivityRequest$Outbound,
+  GetActivityRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function getActivityRequestToJSON(
+  getActivityRequest: GetActivityRequest,
+): string {
+  return JSON.stringify(
+    GetActivityRequest$outboundSchema.parse(getActivityRequest),
+  );
+}
+
+/** @internal */
+export const GetActivityResult$inboundSchema: z.ZodMiniType<
+  GetActivityResult,
+  unknown
+> = z.object({});
+
+export function getActivityResultFromJSON(
+  jsonString: string,
+): SafeParseResult<GetActivityResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetActivityResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetActivityResult' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetActivityResultUnion$inboundSchema: z.ZodMiniType<
+  GetActivityResultUnion,
+  unknown
+> = smartUnion([
+  types.number(),
+  z.lazy(() => GetActivityResult$inboundSchema),
+  types.string(),
+  types.boolean(),
+]);
+
+export function getActivityResultUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<GetActivityResultUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetActivityResultUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetActivityResultUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetActivityType$inboundSchema: z.ZodMiniType<
+  GetActivityType,
+  unknown
+> = openEnums.inboundSchema(GetActivityType);
+
+/** @internal */
+export const GetActivityActivity$inboundSchema: z.ZodMiniType<
+  GetActivityActivity,
+  unknown
+> = z.object({
+  agent: types.nullable(types.boolean()),
+  apiKey: types.nullable(types.string()),
+  case: types.nullable(types.string()),
+  detail: types.string(),
+  id: types.string(),
+  query: types.string(),
+  result: types.nullable(
+    smartUnion([
+      types.number(),
+      z.lazy(() => GetActivityResult$inboundSchema),
+      types.string(),
+      types.boolean(),
+    ]),
+  ),
+  time: types.number(),
+  type: GetActivityType$inboundSchema,
+  user: types.nullable(types.string()),
+});
+
+export function getActivityActivityFromJSON(
+  jsonString: string,
+): SafeParseResult<GetActivityActivity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetActivityActivity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetActivityActivity' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetActivityResponse$inboundSchema: z.ZodMiniType<
+  GetActivityResponse,
+  unknown
+> = z.object({
+  activity: z.lazy(() => GetActivityActivity$inboundSchema),
+  success: types.boolean(),
+});
+
+export function getActivityResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetActivityResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetActivityResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetActivityResponse' from JSON`,
+  );
+}