@indiciaosint/sdk 0.0.1 → 1.0.1-patch

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

@@ -0,0 +1,304 @@
+/*
+ * 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 { smartUnion } from "../../types/smart-union.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export type SearchWhoisRequest = {
+  query: string;
+};
+
+export type VcardArray1 = {};
+
+export type VcardArrayUnion1 = string | { [k: string]: string } | VcardArray1;
+
+export type VcardArrayUnion2 =
+  | string
+  | Array<string | { [k: string]: string } | VcardArray1>;
+
+export type VcardArray2 = {};
+
+export type VcardArrayUnion3 = string | { [k: string]: string } | VcardArray2;
+
+export type VcardArrayUnion4 =
+  | string
+  | Array<string | { [k: string]: string } | VcardArray2>;
+
+export type Entity1 = {
+  roles: Array<string>;
+  vcardArray: Array<
+    string | Array<string | { [k: string]: string } | VcardArray2>
+  >;
+};
+
+export type Entity2 = {
+  handle: string;
+  links: Array<{ [k: string]: string }>;
+  roles: Array<string>;
+  vcardArray: Array<
+    string | Array<string | { [k: string]: string } | VcardArray1>
+  >;
+  entities?: Array<Entity1> | undefined;
+};
+
+export type SearchWhoisData = {
+  entities: Array<Entity2>;
+  events: Array<{ [k: string]: string }>;
+  ldhName: string;
+  nameservers: Array<{ [k: string]: string }>;
+  secureDNS: { [k: string]: string };
+  status: Array<string>;
+};
+
+/**
+ * Search successful
+ */
+export type SearchWhoisResponse = {
+  data: SearchWhoisData;
+  success: boolean;
+  error?: string | undefined;
+};
+
+/** @internal */
+export type SearchWhoisRequest$Outbound = {
+  query: string;
+};
+
+/** @internal */
+export const SearchWhoisRequest$outboundSchema: z.ZodMiniType<
+  SearchWhoisRequest$Outbound,
+  SearchWhoisRequest
+> = z.object({
+  query: z.string(),
+});
+
+export function searchWhoisRequestToJSON(
+  searchWhoisRequest: SearchWhoisRequest,
+): string {
+  return JSON.stringify(
+    SearchWhoisRequest$outboundSchema.parse(searchWhoisRequest),
+  );
+}
+
+/** @internal */
+export const VcardArray1$inboundSchema: z.ZodMiniType<VcardArray1, unknown> = z
+  .object({});
+
+export function vcardArray1FromJSON(
+  jsonString: string,
+): SafeParseResult<VcardArray1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VcardArray1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VcardArray1' from JSON`,
+  );
+}
+
+/** @internal */
+export const VcardArrayUnion1$inboundSchema: z.ZodMiniType<
+  VcardArrayUnion1,
+  unknown
+> = smartUnion([
+  types.string(),
+  z.record(z.string(), types.string()),
+  z.lazy(() => VcardArray1$inboundSchema),
+]);
+
+export function vcardArrayUnion1FromJSON(
+  jsonString: string,
+): SafeParseResult<VcardArrayUnion1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VcardArrayUnion1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VcardArrayUnion1' from JSON`,
+  );
+}
+
+/** @internal */
+export const VcardArrayUnion2$inboundSchema: z.ZodMiniType<
+  VcardArrayUnion2,
+  unknown
+> = smartUnion([
+  types.string(),
+  z.array(
+    smartUnion([
+      types.string(),
+      z.record(z.string(), types.string()),
+      z.lazy(() => VcardArray1$inboundSchema),
+    ]),
+  ),
+]);
+
+export function vcardArrayUnion2FromJSON(
+  jsonString: string,
+): SafeParseResult<VcardArrayUnion2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VcardArrayUnion2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VcardArrayUnion2' from JSON`,
+  );
+}
+
+/** @internal */
+export const VcardArray2$inboundSchema: z.ZodMiniType<VcardArray2, unknown> = z
+  .object({});
+
+export function vcardArray2FromJSON(
+  jsonString: string,
+): SafeParseResult<VcardArray2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VcardArray2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VcardArray2' from JSON`,
+  );
+}
+
+/** @internal */
+export const VcardArrayUnion3$inboundSchema: z.ZodMiniType<
+  VcardArrayUnion3,
+  unknown
+> = smartUnion([
+  types.string(),
+  z.record(z.string(), types.string()),
+  z.lazy(() => VcardArray2$inboundSchema),
+]);
+
+export function vcardArrayUnion3FromJSON(
+  jsonString: string,
+): SafeParseResult<VcardArrayUnion3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VcardArrayUnion3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VcardArrayUnion3' from JSON`,
+  );
+}
+
+/** @internal */
+export const VcardArrayUnion4$inboundSchema: z.ZodMiniType<
+  VcardArrayUnion4,
+  unknown
+> = smartUnion([
+  types.string(),
+  z.array(
+    smartUnion([
+      types.string(),
+      z.record(z.string(), types.string()),
+      z.lazy(() => VcardArray2$inboundSchema),
+    ]),
+  ),
+]);
+
+export function vcardArrayUnion4FromJSON(
+  jsonString: string,
+): SafeParseResult<VcardArrayUnion4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VcardArrayUnion4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VcardArrayUnion4' from JSON`,
+  );
+}
+
+/** @internal */
+export const Entity1$inboundSchema: z.ZodMiniType<Entity1, unknown> = z.object({
+  roles: z.array(types.string()),
+  vcardArray: z.array(
+    smartUnion([
+      types.string(),
+      z.array(
+        smartUnion([
+          types.string(),
+          z.record(z.string(), types.string()),
+          z.lazy(() => VcardArray2$inboundSchema),
+        ]),
+      ),
+    ]),
+  ),
+});
+
+export function entity1FromJSON(
+  jsonString: string,
+): SafeParseResult<Entity1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Entity1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Entity1' from JSON`,
+  );
+}
+
+/** @internal */
+export const Entity2$inboundSchema: z.ZodMiniType<Entity2, unknown> = z.object({
+  handle: types.string(),
+  links: z.array(z.record(z.string(), types.string())),
+  roles: z.array(types.string()),
+  vcardArray: z.array(
+    smartUnion([
+      types.string(),
+      z.array(
+        smartUnion([
+          types.string(),
+          z.record(z.string(), types.string()),
+          z.lazy(() => VcardArray1$inboundSchema),
+        ]),
+      ),
+    ]),
+  ),
+  entities: types.optional(z.array(z.lazy(() => Entity1$inboundSchema))),
+});
+
+export function entity2FromJSON(
+  jsonString: string,
+): SafeParseResult<Entity2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Entity2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Entity2' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWhoisData$inboundSchema: z.ZodMiniType<
+  SearchWhoisData,
+  unknown
+> = z.object({
+  entities: z.array(z.lazy(() => Entity2$inboundSchema)),
+  events: z.array(z.record(z.string(), types.string())),
+  ldhName: types.string(),
+  nameservers: z.array(z.record(z.string(), types.string())),
+  secureDNS: z.record(z.string(), types.string()),
+  status: z.array(types.string()),
+});
+
+export function searchWhoisDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWhoisData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWhoisData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWhoisData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWhoisResponse$inboundSchema: z.ZodMiniType<
+  SearchWhoisResponse,
+  unknown
+> = z.object({
+  data: z.lazy(() => SearchWhoisData$inboundSchema),
+  success: types.boolean(),
+  error: types.optional(types.string()),
+});
+
+export function searchWhoisResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchWhoisResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchWhoisResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchWhoisResponse' from JSON`,
+  );
+}

package/src/models/operations/send-organization-credits.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 SendOrganizationCreditsRequestBody = {
+  creditsEach: number;
+  recipientMemberIds: Array<string>;
+};
+
+export type SendOrganizationCreditsRequest = {
+  id: string;
+  body: SendOrganizationCreditsRequestBody;
+};
+
+/**
+ * Credits sent.
+ */
+export type SendOrganizationCreditsResponse = {
+  sent: number;
+  success: boolean;
+  totalCost: number;
+};
+
+/** @internal */
+export type SendOrganizationCreditsRequestBody$Outbound = {
+  creditsEach: number;
+  recipientMemberIds: Array<string>;
+};
+
+/** @internal */
+export const SendOrganizationCreditsRequestBody$outboundSchema: z.ZodMiniType<
+  SendOrganizationCreditsRequestBody$Outbound,
+  SendOrganizationCreditsRequestBody
+> = z.object({
+  creditsEach: z.number(),
+  recipientMemberIds: z.array(z.string()),
+});
+
+export function sendOrganizationCreditsRequestBodyToJSON(
+  sendOrganizationCreditsRequestBody: SendOrganizationCreditsRequestBody,
+): string {
+  return JSON.stringify(
+    SendOrganizationCreditsRequestBody$outboundSchema.parse(
+      sendOrganizationCreditsRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type SendOrganizationCreditsRequest$Outbound = {
+  id: string;
+  body: SendOrganizationCreditsRequestBody$Outbound;
+};
+
+/** @internal */
+export const SendOrganizationCreditsRequest$outboundSchema: z.ZodMiniType<
+  SendOrganizationCreditsRequest$Outbound,
+  SendOrganizationCreditsRequest
+> = z.object({
+  id: z.string(),
+  body: z.lazy(() => SendOrganizationCreditsRequestBody$outboundSchema),
+});
+
+export function sendOrganizationCreditsRequestToJSON(
+  sendOrganizationCreditsRequest: SendOrganizationCreditsRequest,
+): string {
+  return JSON.stringify(
+    SendOrganizationCreditsRequest$outboundSchema.parse(
+      sendOrganizationCreditsRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const SendOrganizationCreditsResponse$inboundSchema: z.ZodMiniType<
+  SendOrganizationCreditsResponse,
+  unknown
+> = z.object({
+  sent: types.number(),
+  success: types.boolean(),
+  totalCost: types.number(),
+});
+
+export function sendOrganizationCreditsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SendOrganizationCreditsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SendOrganizationCreditsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SendOrganizationCreditsResponse' from JSON`,
+  );
+}

package/src/sdk/activity.ts

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { activityDeleteActivity } from "../funcs/activity-delete-activity.js";
+import { activityGetActivity } from "../funcs/activity-get-activity.js";
+import { activityListActivities } from "../funcs/activity-list-activities.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Activity extends ClientSDK {
+  /**
+   * Get a list of recent activities.
+   */
+  async listActivities(
+    request?: operations.ListActivitiesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListActivitiesResponse> {
+    return unwrapAsync(activityListActivities(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a specific activity by its ID.
+   */
+  async getActivity(
+    request: operations.GetActivityRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetActivityResponse> {
+    return unwrapAsync(activityGetActivity(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a specific activity by its ID.
+   */
+  async deleteActivity(
+    request: operations.DeleteActivityRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(activityDeleteActivity(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/infrastructure.ts

@@ -0,0 +1,243 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { infrastructureScanPorts } from "../funcs/infrastructure-scan-ports.js";
+import { infrastructureSearchCertificates } from "../funcs/infrastructure-search-certificates.js";
+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 { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Infrastructure extends ClientSDK {
+  /**
+   * IP Info
+   *
+   * @remarks
+   * Analyze details of an IP Address.
+   */
+  async searchIpInfo(
+    request: operations.SearchIpInfoRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SearchIpInfoResponse> {
+    return unwrapAsync(infrastructureSearchIpInfo(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * DNS Reconnaissance
+   *
+   * @remarks
+   * Perform deep DNS analysis and find hidden subdomains
+   */
+  async searchDns(
+    request: operations.SearchDnsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SearchDnsResponse> {
+    return unwrapAsync(infrastructureSearchDns(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Shodan Search
+   *
+   * @remarks
+   * IP service and software intelligence
+   */
+  async searchShodan(
+    request: operations.SearchShodanRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SearchShodanResponse> {
+    return unwrapAsync(infrastructureSearchShodan(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Whois
+   *
+   * @remarks
+   * Return information on a domain and its registration
+   */
+  async searchWhois(
+    request: operations.SearchWhoisRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SearchWhoisResponse> {
+    return unwrapAsync(infrastructureSearchWhois(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Port Scan
+   *
+   * @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> {
+    return unwrapAsync(infrastructureScanPorts(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Certificate Lookup
+   *
+   * @remarks
+   * Lookup details about a TLS certificate by domain.
+   */
+  async searchCertificates(
+    request: operations.SearchCertificatesRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SearchCertificatesResponse> {
+    return unwrapAsync(infrastructureSearchCertificates(
+      this,
+      request,
+      options,
+    ));
+  }
+}