@indiciaosint/sdk 1.0.1 → 1.1.0

package/src/models/operations/list-activities.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 ListActivitiesRequest = {
+  limit?: string | undefined;
+  offset?: string | undefined;
+};
+
+export type ListActivitiesResult = {};
+
+export type ListActivitiesResultUnion =
+  | number
+  | ListActivitiesResult
+  | string
+  | boolean;
+
+export const ListActivitiesType = {
+  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 ListActivitiesType = OpenEnum<typeof ListActivitiesType>;
+
+export type ListActivitiesActivity = {
+  agent: boolean | null;
+  apiKey: string | null;
+  case: string | null;
+  detail: string;
+  /**
+   * a RFC-4122-compliant UUID
+   */
+  id: string;
+  query: string;
+  result: number | ListActivitiesResult | string | boolean | null;
+  /**
+   * an integer representing a safe Unix timestamp
+   */
+  time: number;
+  type: ListActivitiesType;
+  user: string | null;
+};
+
+/**
+ * Successful response with a list of activities.
+ */
+export type ListActivitiesResponse = {
+  activities: Array<ListActivitiesActivity>;
+  success: boolean;
+};
+
+/** @internal */
+export type ListActivitiesRequest$Outbound = {
+  limit?: string | undefined;
+  offset?: string | undefined;
+};
+
+/** @internal */
+export const ListActivitiesRequest$outboundSchema: z.ZodMiniType<
+  ListActivitiesRequest$Outbound,
+  ListActivitiesRequest
+> = z.object({
+  limit: z.optional(z.string()),
+  offset: z.optional(z.string()),
+});
+
+export function listActivitiesRequestToJSON(
+  listActivitiesRequest: ListActivitiesRequest,
+): string {
+  return JSON.stringify(
+    ListActivitiesRequest$outboundSchema.parse(listActivitiesRequest),
+  );
+}
+
+/** @internal */
+export const ListActivitiesResult$inboundSchema: z.ZodMiniType<
+  ListActivitiesResult,
+  unknown
+> = z.object({});
+
+export function listActivitiesResultFromJSON(
+  jsonString: string,
+): SafeParseResult<ListActivitiesResult, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListActivitiesResult$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListActivitiesResult' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListActivitiesResultUnion$inboundSchema: z.ZodMiniType<
+  ListActivitiesResultUnion,
+  unknown
+> = smartUnion([
+  types.number(),
+  z.lazy(() => ListActivitiesResult$inboundSchema),
+  types.string(),
+  types.boolean(),
+]);
+
+export function listActivitiesResultUnionFromJSON(
+  jsonString: string,
+): SafeParseResult<ListActivitiesResultUnion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListActivitiesResultUnion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListActivitiesResultUnion' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListActivitiesType$inboundSchema: z.ZodMiniType<
+  ListActivitiesType,
+  unknown
+> = openEnums.inboundSchema(ListActivitiesType);
+
+/** @internal */
+export const ListActivitiesActivity$inboundSchema: z.ZodMiniType<
+  ListActivitiesActivity,
+  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(() => ListActivitiesResult$inboundSchema),
+      types.string(),
+      types.boolean(),
+    ]),
+  ),
+  time: types.number(),
+  type: ListActivitiesType$inboundSchema,
+  user: types.nullable(types.string()),
+});
+
+export function listActivitiesActivityFromJSON(
+  jsonString: string,
+): SafeParseResult<ListActivitiesActivity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListActivitiesActivity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListActivitiesActivity' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListActivitiesResponse$inboundSchema: z.ZodMiniType<
+  ListActivitiesResponse,
+  unknown
+> = z.object({
+  activities: z.array(z.lazy(() => ListActivitiesActivity$inboundSchema)),
+  success: types.boolean(),
+});
+
+export function listActivitiesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListActivitiesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListActivitiesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListActivitiesResponse' from JSON`,
+  );
+}

package/src/models/operations/list-organization-cases.ts

@@ -0,0 +1,95 @@
+/*
+ * 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 ListOrganizationCasesRequest = {
+  id: string;
+};
+
+export type Case = {
+  /**
+   * an integer representing a safe Unix timestamp
+   */
+  createdAt: number;
+  description: string | null;
+  id: string;
+  name: string | null;
+  organizationId: string | null;
+  owner: string;
+};
+
+/**
+ * Shared cases.
+ */
+export type ListOrganizationCasesResponse = {
+  cases: Array<Case>;
+  success: boolean;
+};
+
+/** @internal */
+export type ListOrganizationCasesRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const ListOrganizationCasesRequest$outboundSchema: z.ZodMiniType<
+  ListOrganizationCasesRequest$Outbound,
+  ListOrganizationCasesRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function listOrganizationCasesRequestToJSON(
+  listOrganizationCasesRequest: ListOrganizationCasesRequest,
+): string {
+  return JSON.stringify(
+    ListOrganizationCasesRequest$outboundSchema.parse(
+      listOrganizationCasesRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const Case$inboundSchema: z.ZodMiniType<Case, unknown> = z.object({
+  createdAt: types.number(),
+  description: types.nullable(types.string()),
+  id: types.string(),
+  name: types.nullable(types.string()),
+  organizationId: types.nullable(types.string()),
+  owner: types.string(),
+});
+
+export function caseFromJSON(
+  jsonString: string,
+): SafeParseResult<Case, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Case$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Case' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListOrganizationCasesResponse$inboundSchema: z.ZodMiniType<
+  ListOrganizationCasesResponse,
+  unknown
+> = z.object({
+  cases: z.array(z.lazy(() => Case$inboundSchema)),
+  success: types.boolean(),
+});
+
+export function listOrganizationCasesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListOrganizationCasesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListOrganizationCasesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListOrganizationCasesResponse' from JSON`,
+  );
+}

package/src/models/operations/list-organization-members.ts

@@ -0,0 +1,97 @@
+/*
+ * 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 ListOrganizationMembersRequest = {
+  id: string;
+};
+
+export type Member = {
+  /**
+   * an integer representing a safe Unix timestamp
+   */
+  createdAt: number;
+  displayUsername: string | null;
+  id: string;
+  organizationId: string;
+  role: string;
+  userId: string;
+  username: string | null;
+};
+
+/**
+ * Member list.
+ */
+export type ListOrganizationMembersResponse = {
+  members: Array<Member>;
+  success: boolean;
+};
+
+/** @internal */
+export type ListOrganizationMembersRequest$Outbound = {
+  id: string;
+};
+
+/** @internal */
+export const ListOrganizationMembersRequest$outboundSchema: z.ZodMiniType<
+  ListOrganizationMembersRequest$Outbound,
+  ListOrganizationMembersRequest
+> = z.object({
+  id: z.string(),
+});
+
+export function listOrganizationMembersRequestToJSON(
+  listOrganizationMembersRequest: ListOrganizationMembersRequest,
+): string {
+  return JSON.stringify(
+    ListOrganizationMembersRequest$outboundSchema.parse(
+      listOrganizationMembersRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const Member$inboundSchema: z.ZodMiniType<Member, unknown> = z.object({
+  createdAt: types.number(),
+  displayUsername: types.nullable(types.string()),
+  id: types.string(),
+  organizationId: types.string(),
+  role: types.string(),
+  userId: types.string(),
+  username: types.nullable(types.string()),
+});
+
+export function memberFromJSON(
+  jsonString: string,
+): SafeParseResult<Member, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Member$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Member' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListOrganizationMembersResponse$inboundSchema: z.ZodMiniType<
+  ListOrganizationMembersResponse,
+  unknown
+> = z.object({
+  members: z.array(z.lazy(() => Member$inboundSchema)),
+  success: types.boolean(),
+});
+
+export function listOrganizationMembersResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListOrganizationMembersResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListOrganizationMembersResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListOrganizationMembersResponse' from JSON`,
+  );
+}

package/src/models/operations/list-organizations.ts

@@ -0,0 +1,79 @@
+/*
+ * 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 ListOrganizationsOrganization = {
+  /**
+   * an integer representing a safe Unix timestamp
+   */
+  createdAt: number;
+  defaultCaseVisibility: string;
+  description: string | null;
+  id: string;
+  logo: string | null;
+  memberCount: number;
+  myRole: string | null;
+  name: string;
+  slug: string;
+};
+
+/**
+ * List of organizations with member counts and your role.
+ */
+export type ListOrganizationsResponse = {
+  organizations: Array<ListOrganizationsOrganization>;
+  success: boolean;
+};
+
+/** @internal */
+export const ListOrganizationsOrganization$inboundSchema: z.ZodMiniType<
+  ListOrganizationsOrganization,
+  unknown
+> = z.object({
+  createdAt: types.number(),
+  defaultCaseVisibility: types.string(),
+  description: types.nullable(types.string()),
+  id: types.string(),
+  logo: types.nullable(types.string()),
+  memberCount: types.number(),
+  myRole: types.nullable(types.string()),
+  name: types.string(),
+  slug: types.string(),
+});
+
+export function listOrganizationsOrganizationFromJSON(
+  jsonString: string,
+): SafeParseResult<ListOrganizationsOrganization, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListOrganizationsOrganization$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListOrganizationsOrganization' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListOrganizationsResponse$inboundSchema: z.ZodMiniType<
+  ListOrganizationsResponse,
+  unknown
+> = z.object({
+  organizations: z.array(
+    z.lazy(() => ListOrganizationsOrganization$inboundSchema),
+  ),
+  success: types.boolean(),
+});
+
+export function listOrganizationsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ListOrganizationsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListOrganizationsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListOrganizationsResponse' from JSON`,
+  );
+}

package/src/models/operations/lookup-discord-alt.ts

@@ -0,0 +1,166 @@
+/*
+ * 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 LookupDiscordAltRequest = {
+  query: string;
+};
+
+export type First = {
+  avatar: string;
+  id: string;
+  username: string;
+};
+
+export type Second = {
+  avatar: string;
+  id: string;
+  username: string;
+};
+
+export type Third = {
+  avatar: string;
+  id: string;
+  username: string;
+};
+
+export type LookupDiscordAltData = {
+  first: Array<First>;
+  second: Array<Second>;
+  third: Array<Third>;
+  tier: string;
+  totalalts: number;
+  verifications: number;
+  vpns: number;
+};
+
+/**
+ * Search successful
+ */
+export type LookupDiscordAltResponse = {
+  success: boolean;
+  data?: LookupDiscordAltData | undefined;
+  error?: string | undefined;
+};
+
+/** @internal */
+export type LookupDiscordAltRequest$Outbound = {
+  query: string;
+};
+
+/** @internal */
+export const LookupDiscordAltRequest$outboundSchema: z.ZodMiniType<
+  LookupDiscordAltRequest$Outbound,
+  LookupDiscordAltRequest
+> = z.object({
+  query: z.string(),
+});
+
+export function lookupDiscordAltRequestToJSON(
+  lookupDiscordAltRequest: LookupDiscordAltRequest,
+): string {
+  return JSON.stringify(
+    LookupDiscordAltRequest$outboundSchema.parse(lookupDiscordAltRequest),
+  );
+}
+
+/** @internal */
+export const First$inboundSchema: z.ZodMiniType<First, unknown> = z.object({
+  avatar: types.string(),
+  id: types.string(),
+  username: types.string(),
+});
+
+export function firstFromJSON(
+  jsonString: string,
+): SafeParseResult<First, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => First$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'First' from JSON`,
+  );
+}
+
+/** @internal */
+export const Second$inboundSchema: z.ZodMiniType<Second, unknown> = z.object({
+  avatar: types.string(),
+  id: types.string(),
+  username: types.string(),
+});
+
+export function secondFromJSON(
+  jsonString: string,
+): SafeParseResult<Second, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Second$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Second' from JSON`,
+  );
+}
+
+/** @internal */
+export const Third$inboundSchema: z.ZodMiniType<Third, unknown> = z.object({
+  avatar: types.string(),
+  id: types.string(),
+  username: types.string(),
+});
+
+export function thirdFromJSON(
+  jsonString: string,
+): SafeParseResult<Third, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Third$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Third' from JSON`,
+  );
+}
+
+/** @internal */
+export const LookupDiscordAltData$inboundSchema: z.ZodMiniType<
+  LookupDiscordAltData,
+  unknown
+> = z.object({
+  first: z.array(z.lazy(() => First$inboundSchema)),
+  second: z.array(z.lazy(() => Second$inboundSchema)),
+  third: z.array(z.lazy(() => Third$inboundSchema)),
+  tier: types.string(),
+  totalalts: types.number(),
+  verifications: types.number(),
+  vpns: types.number(),
+});
+
+export function lookupDiscordAltDataFromJSON(
+  jsonString: string,
+): SafeParseResult<LookupDiscordAltData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LookupDiscordAltData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LookupDiscordAltData' from JSON`,
+  );
+}
+
+/** @internal */
+export const LookupDiscordAltResponse$inboundSchema: z.ZodMiniType<
+  LookupDiscordAltResponse,
+  unknown
+> = z.object({
+  success: types.boolean(),
+  data: types.optional(z.lazy(() => LookupDiscordAltData$inboundSchema)),
+  error: types.optional(types.string()),
+});
+
+export function lookupDiscordAltResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<LookupDiscordAltResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LookupDiscordAltResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LookupDiscordAltResponse' from JSON`,
+  );
+}

package/src/models/operations/scan-ports.ts

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type Options = {
+  scanAll?: boolean | undefined;
+  skipPing?: boolean | undefined;
+  udp?: boolean | undefined;
+};
+
+export type ScanPortsRequest = {
+  host: string;
+  options: Options;
+};
+
+/** @internal */
+export type Options$Outbound = {
+  scanAll?: boolean | undefined;
+  skipPing?: boolean | undefined;
+  udp?: boolean | undefined;
+};
+
+/** @internal */
+export const Options$outboundSchema: z.ZodMiniType<Options$Outbound, Options> =
+  z.object({
+    scanAll: z.optional(z.boolean()),
+    skipPing: z.optional(z.boolean()),
+    udp: z.optional(z.boolean()),
+  });
+
+export function optionsToJSON(options: Options): string {
+  return JSON.stringify(Options$outboundSchema.parse(options));
+}
+
+/** @internal */
+export type ScanPortsRequest$Outbound = {
+  host: string;
+  options: Options$Outbound;
+};
+
+/** @internal */
+export const ScanPortsRequest$outboundSchema: z.ZodMiniType<
+  ScanPortsRequest$Outbound,
+  ScanPortsRequest
+> = z.object({
+  host: z.string(),
+  options: z.lazy(() => Options$outboundSchema),
+});
+
+export function scanPortsRequestToJSON(
+  scanPortsRequest: ScanPortsRequest,
+): string {
+  return JSON.stringify(
+    ScanPortsRequest$outboundSchema.parse(scanPortsRequest),
+  );
+}