@binalyze/air-sdk 5.2.0 → 5.4.1

package/dist/types/acquisitions.d.ts

@@ -1,10 +1,15 @@
-export interface AcquisitionsAPI {
-    getProfile: (id: string) => Promise<any>;
-    assignEvidenceTask: (params: {
+import type { AcquisitionProfileDto, AssignedTaskDto } from '../generated/bindings';
+export interface IAssignedTask extends AssignedTaskDto {
+}
+export interface IAcquisitionsAPI {
+    getProfile: (options: {
+        id: string;
+    }) => Promise<AcquisitionProfileDto>;
+    assignEvidenceTask: (options: {
         acquisitionProfileId: string;
-        organizationId: number;
+        organizationId?: number;
         endpointId: string;
-        caseId: string;
+        caseId?: string;
         taskName?: string;
-    }) => Promise<any>;
+    }) => Promise<Array<IAssignedTask>>;
 }

package/dist/types/api-tokens.d.ts

@@ -1,16 +1,43 @@
-export interface ApiTokensAPI {
-    get: (id: string) => Promise<any>;
-    getMany: (organizationId: number, pageNumber?: number, pageSize?: number) => Promise<any>;
-    create: (input: {
-        name: string;
-        roleId: string;
-        description?: string;
-        expirationDate?: string;
-    } | any) => Promise<any>;
-    update: (id: string, input: {
-        roleId?: string;
-        description?: string;
-        expirationDate?: string;
-    } | any) => Promise<any>;
-    delete: (id: string) => Promise<any>;
+import type { ApiTokensCreateData, ApiTokensDeleteResponses, ApiTokensUpdateData } from '../generated/bindings';
+export interface IApiToken {
+    _id: string;
+    name: string;
+    description?: string | null;
+    username: string;
+    token?: string;
+    expirationDate?: string | null;
+    lastUsedAt?: string | null;
+    roleId: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface IApiTokensPage extends Array<IApiToken> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+export interface IGetApiTokensOptions {
+    organizationIds?: number | number[];
+    pageNumber?: number;
+    pageSize?: number;
+    searchTerm?: string;
+}
+export interface IApiTokensAPI {
+    get: (options: {
+        id: string;
+    }) => Promise<IApiToken>;
+    getMany: (options?: IGetApiTokensOptions) => Promise<IApiTokensPage>;
+    create: (options: {
+        input: ApiTokensCreateData['body'];
+    }) => Promise<IApiToken>;
+    update: (options: {
+        id: string;
+        input?: ApiTokensUpdateData['body'];
+    }) => Promise<IApiToken>;
+    delete: (options: {
+        id: string;
+    }) => Promise<ApiTokensDeleteResponses[200]>;
 }

package/dist/types/assets.d.ts

@@ -1,9 +1,148 @@
-export interface AssetsAPI {
-    getMany: (organizationId: number, pageNumber?: number, pageSize?: number) => Promise<any>;
-    getTasks: (id: string, pageNumber?: number, pageSize?: number) => Promise<any>;
-    addTags: (organizationId: number, tags: string[]) => Promise<any>;
-    removeTags: (organizationId: number, tags: string[]) => Promise<any>;
-    assignIsolationTask: (id: string, enabled: boolean, organizationId: number) => Promise<any>;
-    assignRebootTask: (id: string, organizationId: number) => Promise<any>;
-    assignShutdownTask: (id: string, organizationId: number) => Promise<any>;
+import type { AddTagsToEndpointsByFilterDto, AssetsAddTagsData, AssetsAssignIsolationTaskData, AssetsAssignIsolationTaskResponses, AssetsAssignRebootTaskData, AssetsAssignRebootTaskResponses, AssetsAssignShutdownTaskData, AssetsAssignShutdownTaskResponses, AssetsGetManyData, AssetsGetMany4Data, AssetsGetTasksData, AssetsRemoveTagsData, FilterEndpointDto, FilterEndpointTasksDto, RemoveTagsFromEndpointsByFilterDto, RebootEndpointDto, SetIsolationOnEndpointDto, ShutdownEndpointDto } from '../generated/bindings';
+import type { IReadonlyPage, IPaginationMetadata } from './common';
+export interface IAssetEntity {
+    _id: string;
+    name?: string;
+    buildArch?: string;
+    tags?: string[];
+    isolationStatus?: string;
+    netInterfaces?: unknown[];
+    createdAt?: string;
+    updatedAt?: string;
+    organizationId?: number;
+    ipAddress?: string;
+    groupId?: string;
+    groupFullPath?: string;
+    label?: string | null;
+    os?: string;
+    isServer?: boolean;
+    agentInstalled?: boolean;
+    lastSeen?: string;
+    version?: string;
+    versionNo?: number;
+    registeredAt?: string;
+    platform?: string;
+    securityToken?: string;
+    systemResources?: Record<string, unknown>;
+    cloud?: Record<string, unknown>;
+    hasEvidence?: boolean;
+    relayServerId?: string | null;
+    connectionRoute?: string | null;
+    features?: Record<string, unknown>;
+    assetId?: number;
+    assetType?: string;
+    timezoneOffset?: number;
+    vendorId?: string | null;
+    vendorDeviceId?: string | null;
+    responderId?: string;
+    excludedFromUpdates?: boolean;
+    unsupportedOsToUpdate?: boolean;
+    lastRelayId?: string | null;
+    lastRelaySeen?: string | null;
+    onlineStatus?: string;
+    issues?: string[];
+    versionUpdating?: boolean;
+    managedStatus?: string;
+}
+export interface IAssetsPage extends Array<IAssetEntity> {
+    _pagination?: IPaginationMetadata;
+}
+export type IReadonlyAssetsPage = IReadonlyPage<IAssetEntity>;
+export type Asset = IAssetEntity;
+export interface IAssetTaskEntity {
+    _id: string;
+    taskId?: string;
+    name?: string;
+    type?: string;
+    endpointId?: string;
+    endpointName?: string;
+    organizationId?: number;
+    status?: string;
+    subStatus?: string | null;
+    recurrence?: unknown | null;
+    progress?: number;
+    durations?: Record<string, number>;
+    duration?: number;
+    caseIds?: string[];
+    metadata?: Record<string, unknown>;
+    createdAt?: string;
+    createdBy?: string;
+    updatedAt?: string;
+    displayType?: string;
+    response?: Record<string, unknown>;
+    reportUrl?: string;
+}
+export interface IAssetTasksPage extends Array<IAssetTaskEntity> {
+    _pagination?: IPaginationMetadata;
+}
+export type IReadonlyAssetTasksPage = IReadonlyPage<IAssetTaskEntity>;
+export type AssetAssignedTask = (AssetsAssignRebootTaskResponses[201] extends Array<infer R> ? R : never) | (AssetsAssignShutdownTaskResponses[201] extends Array<infer R> ? R : never) | (AssetsAssignIsolationTaskResponses[201] extends Array<infer R> ? R : never);
+export interface IAssetAssignedTasksPage extends Array<IAssetAssignedTaskEntity> {
+    _pagination?: IPaginationMetadata;
+}
+export interface IGetAssetsOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: NonNullable<AssetsGetManyData['query']>['sortBy'];
+    sortType?: NonNullable<AssetsGetManyData['query']>['sortType'];
+    filter?: Partial<FilterEndpointDto>;
+}
+export interface IGetAssetOptions {
+    id: AssetsGetMany4Data['path']['id'];
+}
+export interface IGetAssetTasksOptions {
+    id: AssetsGetTasksData['path']['id'];
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: NonNullable<AssetsGetTasksData['query']>['sortBy'];
+    sortType?: NonNullable<AssetsGetTasksData['query']>['sortType'];
+    filter?: FilterEndpointTasksDto;
+}
+export interface IUpdateAssetTagsOptions {
+    filter?: Partial<FilterEndpointDto> & {
+        organizationIds?: number[];
+    };
+    tags: AddTagsToEndpointsByFilterDto['tags'];
+}
+export interface IRemoveAssetTagsOptions {
+    filter?: Partial<FilterEndpointDto> & {
+        organizationIds?: number[];
+    };
+    tags: RemoveTagsFromEndpointsByFilterDto['tags'];
+}
+export type AssignIsolationTaskOptions = Omit<SetIsolationOnEndpointDto, 'organizationId' | 'filter'> & {
+    organizationId?: number;
+    filter?: Partial<FilterEndpointDto> & {
+        organizationIds?: number[];
+    };
+};
+export type AssignRebootTaskOptions = RebootEndpointDto;
+export type AssignShutdownTaskOptions = ShutdownEndpointDto;
+export interface IAssetsAPI {
+    get: (options: IGetAssetOptions) => Promise<Asset>;
+    getMany: (options?: IGetAssetsOptions) => Promise<IAssetsPage>;
+    getTasks: (options: IGetAssetTasksOptions) => Promise<IAssetTasksPage>;
+    addTags: (options: IUpdateAssetTagsOptions) => Promise<IAddTagsResult>;
+    removeTags: (options: IRemoveAssetTagsOptions) => Promise<RemoveTagsResult>;
+    assignIsolationTask: (options: AssignIsolationTaskOptions) => Promise<IAssetAssignedTasksPage>;
+    assignRebootTask: (options: AssignRebootTaskOptions) => Promise<AssetAssignedTask[]>;
+    assignShutdownTask: (options: AssignShutdownTaskOptions) => Promise<AssetAssignedTask[]>;
+}
+export type AssetsAddTagsPayload = AssetsAddTagsData['body'];
+export type AssetsRemoveTagsPayload = AssetsRemoveTagsData['body'];
+export type AssetsAssignIsolationTaskPayload = AssetsAssignIsolationTaskData['body'];
+export type AssetsAssignRebootTaskPayload = AssetsAssignRebootTaskData['body'];
+export type AssetsAssignShutdownTaskPayload = AssetsAssignShutdownTaskData['body'];
+export interface IAddTagsResult {
+    success: boolean;
+    statusCode?: number;
+    message?: string;
+    matchedCount?: number;
+}
+export type RemoveTagsResult = IAddTagsResult;
+export interface IAssetAssignedTaskEntity {
+    _id: string;
+    name: string;
+    organizationId: number;
+    taskDetailsViewUrl: string;
 }

package/dist/types/baseline.d.ts

@@ -1,5 +1,36 @@
-export interface BaselineAPI {
-    acquire: (endpointId: string, organizationId: number, caseId?: string) => Promise<any>;
-    compare: (endpointId: string, taskIds: string[], taskName?: string, caseId?: string) => Promise<any>;
-    getComparisonReport: (endpointId: string, taskId: string) => Promise<any>;
+import type { AssignedTaskDto } from '../generated/bindings';
+export interface IBaselineAssignedTask extends AssignedTaskDto {
+    taskId: string;
+    taskName?: string;
+}
+export interface IBaselineAcquireFilter {
+    organizationIds?: number[];
+    includedEndpointIds?: string[];
+    excludedEndpointIds?: string[];
+    [key: string]: unknown;
+}
+export interface IBaselineAcquireOptions {
+    filter: IBaselineAcquireFilter;
+    caseId?: string;
+}
+export interface IBaselineCompareOptions {
+    taskIds: string[];
+    endpointId?: string;
+    vendorDeviceId?: string;
+    taskName?: string;
+    caseId?: string;
+}
+export interface IBaselineComparisonReportOptions {
+    endpointId: string;
+    taskId: string;
+}
+export interface IBaselineComparisonReportByVendorDeviceIdOptions {
+    vendorDeviceId: string;
+    taskId: string;
+}
+export interface IBaselineAPI {
+    acquire: (options: IBaselineAcquireOptions) => Promise<IBaselineAssignedTask[]>;
+    compare: (options: IBaselineCompareOptions) => Promise<IBaselineAssignedTask>;
+    getComparisonReport: (options: IBaselineComparisonReportOptions) => Promise<string>;
+    getComparisonReportByVendorDeviceId: (options: IBaselineComparisonReportByVendorDeviceIdOptions) => Promise<string>;
 }

package/dist/types/cases.d.ts

@@ -1,16 +1,128 @@
-export interface CasesAPI {
-    checkName: (name: string) => Promise<any>;
-    get: (id: string) => Promise<any>;
-    getMany: (pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
-    changeOwner: (id: string, newOwnerId: string) => Promise<any>;
-    close: (id: string) => Promise<any>;
-    create: (input: {
+import type { CaseResponseDto, CreateCaseDto, FilterCaseActivitiesDto, FilterCaseTasksDto, FilterCaseUsersDto, FilterUserCasesDto, FilterEndpointDto } from '../generated/bindings';
+import type { IAssetsPage } from './assets';
+import type { IReadonlyPage, IPaginationMetadata } from './common';
+import type { ITaskAssignmentsPage } from './tasks';
+export type Case = CaseResponseDto;
+export interface ICasesPage extends Array<Case> {
+    _pagination?: IPaginationMetadata;
+}
+export type IReadonlyCasesPage = IReadonlyPage<Case>;
+export interface IGetCasesOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortType?: 'ASC' | 'DESC';
+    filter?: Partial<FilterUserCasesDto>;
+}
+export interface ICasesAPI {
+    checkName: (options: {
         name: string;
-        organizationId: number;
-        visibility: 'public-to-organization' | 'private-to-users';
-    } | any) => Promise<any>;
-    getActivities: (id: string, pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
-    getEndpoints: (id: string, pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
-    getTasks: (id: string, pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
-    getUsers: (id: string, pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
+    }) => Promise<boolean>;
+    get: (options: {
+        id: string;
+    }) => Promise<Case>;
+    getMany: (options?: IGetCasesOptions) => Promise<ICasesPage>;
+    changeOwner: (options: {
+        id: string;
+        newOwnerId: string;
+    }) => Promise<Case>;
+    close: (options: {
+        id: string;
+    }) => Promise<Case>;
+    create: (options: {
+        input: CreateCaseInput;
+    }) => Promise<Case>;
+    getActivities: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: FilterCaseActivitiesDto;
+    }) => Promise<ICaseActivitiesPage>;
+    getEndpoints: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: Partial<FilterEndpointDto>;
+    }) => Promise<IAssetsPage>;
+    getTasks: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: FilterCaseTasksDto;
+    }) => Promise<ITaskAssignmentsPage>;
+    getUsers: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: FilterCaseUsersDto;
+    }) => Promise<ICaseUsersPage>;
+}
+export type CreateCaseInput = Omit<CreateCaseDto, 'organizationId' | 'visibility' | 'assignedUserIds'> & {
+    organizationId?: number;
+    visibility?: NonNullable<CreateCaseDto['visibility']>;
+    assignedUserIds?: CreateCaseDto['assignedUserIds'];
+};
+export interface ICaseActivityOptions {
+    username?: string;
+    apiTokenName?: string;
+    eventOrigin?: string;
+    organizationIds?: number[];
+}
+export interface ICaseActivityData {
+    [key: string]: unknown;
+    name?: string;
+    caseId?: string;
+    options?: ICaseActivityOptions;
+    organizationId?: number;
+    organizationIds?: number[];
+    ownerUser?: string;
+    visibility?: string;
+    eventSource?: string;
+    eventVersion?: number;
+    assignedUsers?: string[];
+    publishedDate?: string;
+    oldCaseOwnerName?: string;
+    newCaseOwnerName?: string;
+    endpointId?: string;
+    endpointName?: string;
+}
+export interface ICaseActivityEntity {
+    id: number;
+    caseId: string;
+    type: string;
+    performedBy: string;
+    data: ICaseActivityData;
+    createdAt: string;
+    description?: string | null;
+}
+export interface ICaseActivitiesPage extends Array<ICaseActivityEntity> {
+    _pagination?: IPaginationMetadata;
+}
+export type IReadonlyCaseActivitiesPage = IReadonlyPage<ICaseActivityEntity>;
+export interface ICaseUserEntity {
+    _id: string;
+    email?: string;
+    username?: string;
+    roles?: unknown[];
+    profile?: {
+        name?: string;
+        surname?: string;
+        department?: string;
+    };
+    hasPassword?: boolean;
+    organizationIds?: number[] | 'ALL';
+    tfaEnabled?: boolean;
+    isAuthorizedForAllOrganizations?: boolean;
+    isGlobalAdmin?: boolean;
+    isOrganizationAdmin?: boolean;
+    isNotInOrganizations?: boolean;
+    lastLogin?: string | null;
+    onlineStatus?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    strategy?: string;
+}
+export interface ICaseUsersPage extends Array<ICaseUserEntity> {
+    _pagination?: IPaginationMetadata;
 }
+export type IReadonlyCaseUsersPage = IReadonlyPage<ICaseUserEntity>;

package/dist/types/common.d.ts

@@ -0,0 +1,27 @@
+export interface IPaginationMetadata {
+    totalEntityCount?: number;
+    pageSize?: number;
+    currentPage?: number;
+    totalPageCount?: number;
+}
+export type IReadonlyPage<T> = ReadonlyArray<T> & {
+    _pagination?: IPaginationMetadata;
+};
+export interface ISDKError {
+    message: string;
+    statusCode?: number;
+    code?: string;
+}
+export type ResultSuccess<T> = {
+    success: true;
+    result: T;
+    statusCode: number;
+};
+export type ResultFailure = {
+    success: false;
+    result: null;
+    statusCode: number;
+    message: string;
+    code?: string;
+};
+export type Result<T> = ResultSuccess<T> | ResultFailure;

package/dist/types/common.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=common.js.map

package/dist/types/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -9,3 +9,5 @@ export * from './organization';
 export * from './repositories';
 export * from './tasks';
 export * from './triage';
+export * from './common';
+export * from './investigation';

package/dist/types/index.js

@@ -25,4 +25,6 @@ __exportStar(require("./organization"), exports);
 __exportStar(require("./repositories"), exports);
 __exportStar(require("./tasks"), exports);
 __exportStar(require("./triage"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./investigation"), exports);
 //# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,iDAA+B;AAC/B,2CAAyB;AACzB,+CAA6B;AAC7B,6CAA2B;AAC3B,0CAAwB;AACxB,6CAA2B;AAC3B,iDAA+B;AAC/B,iDAA+B;AAC/B,0CAAwB;AACxB,2CAAyB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,iDAA+B;AAC/B,2CAAyB;AACzB,+CAA6B;AAC7B,6CAA2B;AAC3B,0CAAwB;AACxB,6CAA2B;AAC3B,iDAA+B;AAC/B,iDAA+B;AAC/B,0CAAwB;AACxB,2CAAyB;AACzB,2CAAyB;AACzB,kDAAgC"}

package/dist/types/interact.d.ts

@@ -1,9 +1,62 @@
-export interface InteractAPI {
-    getCommands: () => Promise<any>;
-    createShellSession: (assetId: string, caseId: string, taskName: string, taskConfig?: unknown) => Promise<any>;
-    executeSyncCommand: (sessionId: string, command: string) => Promise<any>;
-    executeAsyncCommand: (sessionId: string, command: string) => Promise<any>;
-    getCommandMessage: (sessionId: string, messageId: string) => Promise<any>;
-    interruptCommand: (sessionId: string, messageId: string) => Promise<any>;
-    closeSession: (sessionId: string) => Promise<any>;
+import type { InteractShellAssignTaskData, InteractShellAssignTaskResponses, InteractSessionCloseData, InteractSessionCloseResponses, InteractSessionExecuteAsyncCommandData, InteractSessionExecuteAsyncCommandResponses, InteractSessionExecuteCommandData, InteractSessionExecuteCommandResponses, InteractSessionGetCommandMessageData, InteractSessionGetCommandMessageResponses, InteractSessionInterruptCommandData, InteractSessionInterruptCommandResponses } from '../generated/bindings';
+export interface IInteractCommandOption {
+    name: string;
+    abbreviations: string[];
+    effect: string;
+    required: boolean;
 }
+export interface IInteractCommand {
+    command: string[];
+    description?: string;
+    options: IInteractCommandOption[];
+    privilege: string;
+    usage: string[];
+}
+export type InteractShellSession = InteractShellAssignTaskResponses[201];
+export type InteractCommandExecutionResult = InteractSessionExecuteCommandResponses[200];
+export type InteractAsyncCommandResult = InteractSessionExecuteAsyncCommandResponses[200];
+export type InteractCommandMessage = InteractSessionGetCommandMessageResponses[200];
+export type InteractInterruptCommandResult = InteractSessionInterruptCommandResponses[200];
+export type InteractCloseSessionResult = InteractSessionCloseResponses[200];
+export interface ICloseSessionResult {
+    success: boolean;
+    sessionId?: string;
+    statusCode?: number;
+    message?: string;
+}
+type InteractShellAssignTaskBody = InteractShellAssignTaskData['body'];
+export type CreateInteractShellSessionOptions = Omit<InteractShellAssignTaskBody, 'vendorId' | 'assetId' | 'vendorDeviceId' | 'taskName' | 'caseId' | 'taskConfig'> & {
+    vendorId?: string;
+    assetId?: string;
+    vendorDeviceId?: string;
+    taskName?: string;
+    caseId?: string;
+    taskConfig?: InteractShellAssignTaskBody['taskConfig'];
+};
+export type ExecuteInteractCommandOptions = InteractSessionExecuteCommandData['body'] & {
+    sessionId: InteractSessionExecuteCommandData['path']['sessionId'];
+};
+export type ExecuteInteractAsyncCommandOptions = InteractSessionExecuteAsyncCommandData['body'] & {
+    sessionId: InteractSessionExecuteAsyncCommandData['path']['sessionId'];
+};
+export interface IGetInteractCommandMessageOptions {
+    sessionId: InteractSessionGetCommandMessageData['path']['sessionId'];
+    messageId: InteractSessionGetCommandMessageData['path']['messageId'];
+}
+export interface IInterruptInteractCommandOptions {
+    sessionId: InteractSessionInterruptCommandData['path']['sessionId'];
+    messageId: InteractSessionInterruptCommandData['path']['messageId'];
+}
+export interface ICloseInteractSessionOptions {
+    sessionId: InteractSessionCloseData['path']['sessionId'];
+}
+export interface IInteractAPI {
+    getCommands: () => Promise<IInteractCommand[]>;
+    createShellSession: (options: CreateInteractShellSessionOptions) => Promise<InteractShellSession>;
+    executeCommand: (options: ExecuteInteractCommandOptions) => Promise<InteractCommandExecutionResult>;
+    executeAsyncCommand: (options: ExecuteInteractAsyncCommandOptions) => Promise<InteractAsyncCommandResult>;
+    getCommandMessage: (options: IGetInteractCommandMessageOptions) => Promise<InteractCommandMessage>;
+    interruptCommand: (options: IInterruptInteractCommandOptions) => Promise<InteractInterruptCommandResult>;
+    closeSession: (options: ICloseInteractSessionOptions) => Promise<ICloseSessionResult>;
+}
+export {};

package/dist/types/investigation.d.ts

@@ -0,0 +1,75 @@
+import type { FilterInvestigationFindingsDtoWritable, FilterInvestigationActivitiesDtoWritable, InvestigationFindingsStructureResponseDto, InvestigationFindingsSummaryResponseDto, InvestigationMitreTacticDto, InvestigationActivityDto, InvestigationFindingsPageDto } from '../generated/bindings';
+import type { PageWithPagination } from '../utils';
+export type InvestigationHubFindingsStructure = InvestigationFindingsStructureResponseDto;
+export type InvestigationHubFinding = InvestigationFindingsPageDto['entities'][number];
+export type InvestigationHubFindings = InvestigationFindingsPageDto;
+export type InvestigationHubFindingsSummary = InvestigationFindingsSummaryResponseDto;
+export type InvestigationHubMitreTactic = InvestigationMitreTacticDto;
+export type InvestigationActivityData = {
+    flagId?: number;
+    source?: string;
+    assetId?: string;
+    evidence?: string;
+    flagName?: string;
+    objectId?: number;
+    platform?: string;
+    username?: string;
+    assetName?: string;
+    flagDescription?: string;
+    taskAssignmentId?: string;
+} & Record<string, unknown>;
+export type InvestigationHubActivity = Omit<InvestigationActivityDto, 'data'> & {
+    data: InvestigationActivityData;
+};
+export type InvestigationActivitiesPage = PageWithPagination<InvestigationHubActivity>;
+export interface IGetFindingsStructureOptions {
+    investigationId: string;
+}
+export interface IGetFindingsOptions {
+    investigationId: string;
+    assignmentIds?: string[];
+    /** alias accepted by wrapper; mapped to assignmentIds */
+    includedEndpointIds?: string[];
+    filter?: FilterInvestigationFindingsDtoWritable['filter'];
+    onlyExcludedFindings?: boolean;
+    skip?: number;
+    take?: number;
+    sort?: NonNullable<FilterInvestigationFindingsDtoWritable['sort']>;
+}
+export interface IGetFindingsSummaryOptions {
+    investigationId: string;
+    assignmentIds?: string[];
+    includedEndpointIds?: string[];
+    findingTypes?: string[];
+    flagIds?: number[];
+    findingCreatedBy?: ('DRONE' | 'USER')[];
+    mitreTechniqueIds?: string[];
+    mitreTacticIds?: string[];
+    dateTimeRange?: unknown;
+}
+export interface IGetMitreMatchesOptions {
+    investigationId: string;
+    assignmentIds?: string[];
+    includedEndpointIds?: string[];
+    findingTypes?: string[];
+    flagIds?: number[];
+    findingCreatedBy?: ('DRONE' | 'USER')[];
+    mitreTechniqueIds?: string[];
+    mitreTacticIds?: string[];
+    dateTimeRange?: unknown;
+}
+export interface IGetActivitiesOptions {
+    investigationId: string;
+    filter?: Partial<FilterInvestigationActivitiesDtoWritable>;
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortType?: 'ASC' | 'DESC';
+}
+export interface IInvestigationHubAPI {
+    getFindingsStructure: (options: IGetFindingsStructureOptions) => Promise<InvestigationHubFindingsStructure>;
+    getFindings: (options: IGetFindingsOptions) => Promise<InvestigationHubFindings>;
+    getFindingsSummary: (options: IGetFindingsSummaryOptions) => Promise<InvestigationHubFindingsSummary>;
+    getMitreMatches: (options: IGetMitreMatchesOptions) => Promise<InvestigationHubMitreTactic[]>;
+    getActivities: (options: IGetActivitiesOptions) => Promise<InvestigationActivitiesPage>;
+}

package/dist/types/investigation.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=investigation.js.map

package/dist/types/investigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"investigation.js","sourceRoot":"","sources":["../../src/types/investigation.ts"],"names":[],"mappings":""}