@indiciaosint/sdk 1.0.1 → 1.0.3

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

@@ -0,0 +1,161 @@
+/*
+ * 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 SearchWhoisRequest = {
+  query: string;
+};
+
+export type Dates = {
+  created?: string | undefined;
+  expires?: string | undefined;
+};
+
+export type Raw = {};
+
+export type Registrar = {
+  abuseEmail: string;
+  abusePhone: string;
+  ianaId: string;
+  name: string;
+  url: string;
+};
+
+export type SearchWhoisData = {
+  dates: Dates;
+  dnssec: { [k: string]: any };
+  domain: string;
+  nameservers: Array<{ [k: string]: any }>;
+  raw: Raw;
+  registrar: Registrar;
+  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 Dates$inboundSchema: z.ZodMiniType<Dates, unknown> = z.object({
+  created: types.optional(types.string()),
+  expires: types.optional(types.string()),
+});
+
+export function datesFromJSON(
+  jsonString: string,
+): SafeParseResult<Dates, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Dates$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Dates' from JSON`,
+  );
+}
+
+/** @internal */
+export const Raw$inboundSchema: z.ZodMiniType<Raw, unknown> = z.object({});
+
+export function rawFromJSON(
+  jsonString: string,
+): SafeParseResult<Raw, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Raw$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Raw' from JSON`,
+  );
+}
+
+/** @internal */
+export const Registrar$inboundSchema: z.ZodMiniType<Registrar, unknown> = z
+  .object({
+    abuseEmail: types.string(),
+    abusePhone: types.string(),
+    ianaId: types.string(),
+    name: types.string(),
+    url: types.string(),
+  });
+
+export function registrarFromJSON(
+  jsonString: string,
+): SafeParseResult<Registrar, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Registrar$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Registrar' from JSON`,
+  );
+}
+
+/** @internal */
+export const SearchWhoisData$inboundSchema: z.ZodMiniType<
+  SearchWhoisData,
+  unknown
+> = z.object({
+  dates: z.lazy(() => Dates$inboundSchema),
+  dnssec: z.record(z.string(), z.any()),
+  domain: types.string(),
+  nameservers: z.array(z.record(z.string(), z.any())),
+  raw: z.lazy(() => Raw$inboundSchema),
+  registrar: z.lazy(() => Registrar$inboundSchema),
+  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,
+    ));
+  }
+}