@binalyze/air-sdk 5.2.0 → 5.4.0

package/dist/types/acquisitions.d.ts

@@ -1,10 +1,15 @@
+import type { AcquisitionProfileDto, AssignedTaskDto } from '../generated/bindings';
+export interface AssignedTask extends AssignedTaskDto {
+}
 export interface AcquisitionsAPI {
-    getProfile: (id: string) => Promise<any>;
-    assignEvidenceTask: (params: {
+    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<AssignedTask>>;
 }

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

@@ -1,16 +1,43 @@
+import type { ApiTokensCreateData, ApiTokensDeleteResponses, ApiTokensUpdateData } from '../generated/bindings';
+export interface ApiToken {
+    _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 ApiTokensPage extends Array<ApiToken> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+export interface GetApiTokensOptions {
+    organizationIds?: number | number[];
+    pageNumber?: number;
+    pageSize?: number;
+    searchTerm?: string;
+}
 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>;
+    get: (options: {
+        id: string;
+    }) => Promise<ApiToken>;
+    getMany: (options?: GetApiTokensOptions) => Promise<ApiTokensPage>;
+    create: (options: {
+        input: ApiTokensCreateData['body'];
+    }) => Promise<ApiToken>;
+    update: (options: {
+        id: string;
+        input?: ApiTokensUpdateData['body'];
+    }) => Promise<ApiToken>;
+    delete: (options: {
+        id: string;
+    }) => Promise<ApiTokensDeleteResponses[200]>;
 }

package/dist/types/assets.d.ts

@@ -1,9 +1,160 @@
+import type { AddTagsToEndpointsByFilterDto, AssetsAddTagsData, AssetsAssignIsolationTaskData, AssetsAssignIsolationTaskResponses, AssetsAssignRebootTaskData, AssetsAssignRebootTaskResponses, AssetsAssignShutdownTaskData, AssetsAssignShutdownTaskResponses, AssetsGetManyData, AssetsGetMany4Data, AssetsGetTasksData, AssetsRemoveTagsData, FilterEndpointDto, FilterEndpointTasksDto, RemoveTagsFromEndpointsByFilterDto, RebootEndpointDto, SetIsolationOnEndpointDto, ShutdownEndpointDto } from '../generated/bindings';
+export interface AssetEntity {
+    _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 AssetsPage extends Array<AssetEntity> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+export type Asset = AssetEntity;
+export interface AssetTaskEntity {
+    _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 AssetTasksPage extends Array<AssetTaskEntity> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+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 AssetAssignedTasksPage extends Array<AssetAssignedTaskEntity> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+export interface GetAssetsOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: NonNullable<AssetsGetManyData['query']>['sortBy'];
+    sortType?: NonNullable<AssetsGetManyData['query']>['sortType'];
+    filter?: Partial<FilterEndpointDto>;
+}
+export interface GetAssetOptions {
+    id: AssetsGetMany4Data['path']['id'];
+}
+export interface GetAssetTasksOptions {
+    id: AssetsGetTasksData['path']['id'];
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: NonNullable<AssetsGetTasksData['query']>['sortBy'];
+    sortType?: NonNullable<AssetsGetTasksData['query']>['sortType'];
+    filter?: FilterEndpointTasksDto;
+}
+export interface UpdateAssetTagsOptions {
+    filter?: Partial<FilterEndpointDto> & {
+        organizationIds?: number[];
+    };
+    tags: AddTagsToEndpointsByFilterDto['tags'];
+}
+export interface RemoveAssetTagsOptions {
+    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 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>;
+    get: (options: GetAssetOptions) => Promise<Asset>;
+    getMany: (options?: GetAssetsOptions) => Promise<AssetsPage>;
+    getTasks: (options: GetAssetTasksOptions) => Promise<AssetTasksPage>;
+    addTags: (options: UpdateAssetTagsOptions) => Promise<AddTagsResult>;
+    removeTags: (options: RemoveAssetTagsOptions) => Promise<RemoveTagsResult>;
+    assignIsolationTask: (options: AssignIsolationTaskOptions) => Promise<AssetAssignedTasksPage>;
+    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 AddTagsResult {
+    success: boolean;
+    statusCode?: number;
+    message?: string;
+    matchedCount?: number;
+}
+export type RemoveTagsResult = AddTagsResult;
+export interface AssetAssignedTaskEntity {
+    _id: string;
+    name: string;
+    organizationId: number;
+    taskDetailsViewUrl: string;
 }

package/dist/types/baseline.d.ts

@@ -1,5 +1,36 @@
+import type { AssignedTaskDto } from '../generated/bindings';
+export interface BaselineAssignedTask extends AssignedTaskDto {
+    taskId: string;
+    taskName?: string;
+}
+export interface BaselineAcquireFilter {
+    organizationIds?: number[];
+    includedEndpointIds?: string[];
+    excludedEndpointIds?: string[];
+    [key: string]: unknown;
+}
+export interface BaselineAcquireOptions {
+    filter: BaselineAcquireFilter;
+    caseId?: string;
+}
+export interface BaselineCompareOptions {
+    taskIds: string[];
+    endpointId?: string;
+    vendorDeviceId?: string;
+    taskName?: string;
+    caseId?: string;
+}
+export interface BaselineComparisonReportOptions {
+    endpointId: string;
+    taskId: string;
+}
+export interface BaselineComparisonReportByVendorDeviceIdOptions {
+    vendorDeviceId: string;
+    taskId: string;
+}
 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>;
+    acquire: (options: BaselineAcquireOptions) => Promise<BaselineAssignedTask[]>;
+    compare: (options: BaselineCompareOptions) => Promise<BaselineAssignedTask>;
+    getComparisonReport: (options: BaselineComparisonReportOptions) => Promise<string>;
+    getComparisonReportByVendorDeviceId: (options: BaselineComparisonReportByVendorDeviceIdOptions) => Promise<string>;
 }

package/dist/types/cases.d.ts

@@ -1,16 +1,143 @@
+import type { CaseDto, CreateCaseDto, FilterCaseActivitiesDto, FilterCaseTasksDto, FilterCaseUsersDto, FilterUserCasesDto, FilterEndpointDto } from '../generated/bindings';
+import type { AssetsPage } from './assets';
+import type { TaskAssignmentsPage } from './tasks';
+export interface CaseEntity {
+    createdAt?: string;
+    updatedAt?: string;
+}
+export type Case = CaseDto & CaseEntity;
+export interface CasesPage extends Array<Case> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+export interface GetCasesOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortType?: 'ASC' | 'DESC';
+    filter?: Partial<FilterUserCasesDto>;
+}
 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: {
+    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?: GetCasesOptions) => Promise<CasesPage>;
+    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<CaseActivitiesPage>;
+    getEndpoints: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: Partial<FilterEndpointDto>;
+    }) => Promise<AssetsPage>;
+    getTasks: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: FilterCaseTasksDto;
+    }) => Promise<TaskAssignmentsPage>;
+    getUsers: (options: {
+        id: string;
+        pageNumber?: number;
+        pageSize?: number;
+        filter?: FilterCaseUsersDto;
+    }) => Promise<CaseUsersPage>;
+}
+export type CreateCaseInput = Omit<CreateCaseDto, 'organizationId' | 'visibility' | 'assignedUserIds'> & {
+    organizationId?: number;
+    visibility?: NonNullable<CreateCaseDto['visibility']>;
+    assignedUserIds?: CreateCaseDto['assignedUserIds'];
+};
+export interface CaseActivityOptions {
+    username?: string;
+    apiTokenName?: string;
+    eventOrigin?: string;
+    organizationIds?: number[];
+}
+export interface CaseActivityData {
+    [key: string]: unknown;
+    name?: string;
+    caseId?: string;
+    options?: CaseActivityOptions;
+    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 CaseActivityEntity {
+    id: number;
+    caseId: string;
+    type: string;
+    performedBy: string;
+    data: CaseActivityData;
+    createdAt: string;
+    description?: string | null;
+}
+export interface CaseActivitiesPage extends Array<CaseActivityEntity> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+}
+export interface CaseUserEntity {
+    _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 CaseUsersPage extends Array<CaseUserEntity> {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
 }

package/dist/types/interact.d.ts

@@ -1,9 +1,62 @@
+import type { InteractShellAssignTaskData, InteractShellAssignTaskResponses, InteractSessionCloseData, InteractSessionCloseResponses, InteractSessionExecuteAsyncCommandData, InteractSessionExecuteAsyncCommandResponses, InteractSessionExecuteCommandData, InteractSessionExecuteCommandResponses, InteractSessionGetCommandMessageData, InteractSessionGetCommandMessageResponses, InteractSessionInterruptCommandData, InteractSessionInterruptCommandResponses } from '../generated/bindings';
+export interface InteractCommandOption {
+    name: string;
+    abbreviations: string[];
+    effect: string;
+    required: boolean;
+}
+export interface InteractCommand {
+    command: string[];
+    description?: string;
+    options: InteractCommandOption[];
+    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 CloseSessionResult {
+    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 GetInteractCommandMessageOptions {
+    sessionId: InteractSessionGetCommandMessageData['path']['sessionId'];
+    messageId: InteractSessionGetCommandMessageData['path']['messageId'];
+}
+export interface InterruptInteractCommandOptions {
+    sessionId: InteractSessionInterruptCommandData['path']['sessionId'];
+    messageId: InteractSessionInterruptCommandData['path']['messageId'];
+}
+export interface CloseInteractSessionOptions {
+    sessionId: InteractSessionCloseData['path']['sessionId'];
+}
 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>;
+    getCommands: () => Promise<InteractCommand[]>;
+    createShellSession: (options: CreateInteractShellSessionOptions) => Promise<InteractShellSession>;
+    executeCommand: (options: ExecuteInteractCommandOptions) => Promise<InteractCommandExecutionResult>;
+    executeAsyncCommand: (options: ExecuteInteractAsyncCommandOptions) => Promise<InteractAsyncCommandResult>;
+    getCommandMessage: (options: GetInteractCommandMessageOptions) => Promise<InteractCommandMessage>;
+    interruptCommand: (options: InterruptInteractCommandOptions) => Promise<InteractInterruptCommandResult>;
+    closeSession: (options: CloseInteractSessionOptions) => Promise<CloseSessionResult>;
 }
+export {};

package/dist/types/organization.d.ts

@@ -1,13 +1,74 @@
+import type { OrganizationsGetManyData, OrganizationGetResponses, OrganizationGetData, OrganizationCreateData, OrganizationCreateResponses, OrganizationUpdateData, OrganizationRemoveUsersData, OrganizationAssignUsersData, OrganizationRemoveTagsData, OrganizationAddTagsData, OrganizationGetUsersResponses, OrganizationUpdateShareableDeploymentStatusData, OrganizationUpdateDeploymentTokenData, FilterOrganizationUsersDto } from '../generated/bindings';
+export type Organization = OrganizationGetResponses[200];
+export type OrganizationsPage = (OrganizationListItem[]) & {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+};
+export type OrganizationUser = OrganizationGetUsersResponses[200] extends infer T ? T extends {
+    entities: Array<infer U>;
+} ? U : unknown : unknown;
+export type OrganizationUsersPage = (OrganizationUser[]) & {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+};
+export type OrganizationListItem = OrganizationCreateResponses[201];
+export type AssignUsersResult = {
+    organization: Organization;
+    requestedUserIds: string[];
+    assignedUserIds: string[];
+    notAssignedUserIds: string[];
+};
 export interface OrganizationAPI {
-    addTags: (organizationId: number, tags: string[]) => Promise<any>;
-    assignUsers: (organizationId: number, userIds: string[]) => Promise<any>;
-    checkNameExists: (name: string) => Promise<any>;
-    create: (input: any) => Promise<any>;
-    get: (organizationId: number) => Promise<any>;
-    getMany: (pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
-    getUsers: (organizationId: number, pageNumber?: number, pageSize?: number, filter?: unknown) => Promise<any>;
-    removeTags: (organizationId: number, tags: string[]) => Promise<any>;
-    removeUsers: (organizationId: number, userIds: string[]) => Promise<any>;
-    update: (organizationId: number, input: any) => Promise<any>;
-    updateShareableDeploymentStatus: (organizationId: number, status: boolean) => Promise<any>;
+    addTags: (options: {
+        id?: number;
+        tags: OrganizationAddTagsData['body']['tags'];
+    }) => Promise<OrganizationListItem>;
+    assignUsers: (options: {
+        id?: number;
+        userIds: OrganizationAssignUsersData['body']['userIds'];
+    }) => Promise<AssignUsersResult>;
+    checkNameExists: (options: {
+        name: string;
+    }) => Promise<boolean>;
+    create: (options: {
+        input: OrganizationCreateData['body'];
+    }) => Promise<OrganizationListItem>;
+    get: (options?: OrganizationGetData['path']) => Promise<Organization>;
+    getMany: (options?: OrganizationsGetManyData['query']) => Promise<OrganizationsPage>;
+    getUsers: (options?: {
+        id?: number;
+        pageNumber?: number;
+        pageSize?: number;
+        sortType?: 'ASC' | 'DESC';
+        sortBy?: string;
+        filter?: FilterOrganizationUsersDto;
+    }) => Promise<OrganizationUsersPage>;
+    removeTags: (options: {
+        id?: number;
+        tags: OrganizationRemoveTagsData['body']['tags'];
+    }) => Promise<OrganizationListItem>;
+    removeUsers: (options: {
+        id?: number;
+        userIds: OrganizationRemoveUsersData['body']['userIds'];
+    }) => Promise<Organization>;
+    update: (options: {
+        id?: number;
+        input: OrganizationUpdateData['body'];
+    }) => Promise<OrganizationListItem>;
+    updateShareableDeploymentStatus: (options: {
+        id?: number;
+        status: OrganizationUpdateShareableDeploymentStatusData['body']['status'];
+    }) => Promise<boolean>;
+    updateDeploymentToken: (options: {
+        id?: number;
+        token: OrganizationUpdateDeploymentTokenData['body']['deploymentToken'];
+    }) => Promise<string>;
 }

package/dist/types/repositories.d.ts

@@ -1,4 +1,24 @@
+import type { EvidenceRepositoryFilterDto, EvidenceRepositoriesGetResponses } from '../generated/bindings';
+export type EvidenceRepository = EvidenceRepositoriesGetResponses[200];
+export type EvidenceRepositoriesPage = (EvidenceRepository[]) & {
+    _pagination?: {
+        totalEntityCount?: number;
+        pageSize?: number;
+        currentPage?: number;
+        totalPageCount?: number;
+    };
+};
+export interface GetEvidenceRepositoryOptions {
+    id: string;
+}
+export interface GetEvidenceRepositoriesOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortType?: 'ASC' | 'DESC';
+    filter?: Partial<EvidenceRepositoryFilterDto>;
+}
 export interface RepositoriesAPI {
-    get: (id: string) => Promise<any>;
-    getMany: (organizationIds: number[], pageNumber?: number, pageSize?: number) => Promise<any>;
+    get: (options: GetEvidenceRepositoryOptions) => Promise<EvidenceRepository>;
+    getMany: (options?: GetEvidenceRepositoriesOptions) => Promise<EvidenceRepositoriesPage>;
 }