@jupiterone/jupiterone-mcp/dist/client/jupiterone-client.d.ts

Model Context Protocol server for JupiterOne account rules and rule details

import type { JupiterOneConfig } from '../types/jupiterone.js';
import { AlertService } from './services/alert-service.js';
import { RuleService } from './services/rule-service.js';
import { DashboardService } from './services/dashboard-service.js';
import { IntegrationService } from './services/integration-service.js';
import { J1qlService } from './services/j1ql-service.js';
export declare class JupiterOneClient {
    private client;
    private config;
    private alertService;
    ruleService: RuleService;
    dashboardService: DashboardService;
    private accountService;
    private integrationService;
    j1qlService: J1qlService;
    constructor(config: JupiterOneConfig);
    cloneWithAccountId(accountId: string): JupiterOneClient;
    getAllAlertInstances(...args: Parameters<AlertService['getAllAlertInstances']>): Promise<import("../types/jupiterone.js").AlertRuleInstance[]>;
    listRuleInstances(...args: Parameters<RuleService['listRuleInstances']>): Promise<{
        questionInstances: import("../types/jupiterone.js").QuestionRuleInstance[];
        pageInfo: import("../types/jupiterone.js").PageInfo;
    }>;
    getAllRuleInstances(...args: Parameters<RuleService['getAllRuleInstances']>): Promise<import("../types/jupiterone.js").QuestionRuleInstance[]>;
    createInlineQuestionRuleInstance(...args: Parameters<RuleService['createInlineQuestionRuleInstance']>): Promise<import("../types/jupiterone.js").InlineQuestionRuleInstance>;
    updateInlineQuestionRuleInstance(...args: Parameters<RuleService['updateInlineQuestionRuleInstance']>): Promise<import("../types/jupiterone.js").InlineQuestionRuleInstance>;
    evaluateRuleInstance(...args: Parameters<RuleService['evaluateRuleInstance']>): Promise<{
        id: string;
        __typename: string;
    }>;
    getAllRuleEvaluations(...args: Parameters<RuleService['getAllRuleEvaluations']>): Promise<import("../types/jupiterone.js").RuleEvaluation[]>;
    getRuleEvaluationDetails(...args: Parameters<RuleService['getRuleEvaluationDetails']>): Promise<import("../types/jupiterone.js").RuleEvaluationDetails>;
    getRawDataDownloadUrl(...args: Parameters<RuleService['getRawDataDownloadUrl']>): Promise<string>;
    getRawDataResults(...args: Parameters<RuleService['getRawDataResults']>): Promise<any>;
    getDashboards(): Promise<import("../types/jupiterone.js").Dashboard[]>;
    createDashboard(...args: Parameters<DashboardService['createDashboard']>): Promise<{
        id: string;
        __typename: string;
    }>;
    getDashboard(...args: Parameters<DashboardService['getDashboard']>): Promise<import("../types/jupiterone.js").DashboardDetails>;
    createDashboardWidget(...args: Parameters<DashboardService['createDashboardWidget']>): Promise<any>;
    updateDashboard(...args: Parameters<DashboardService['updateDashboard']>): Promise<any>;
    deleteDashboardWidget(...args: Parameters<DashboardService['deleteDashboardWidget']>): Promise<{
        success: boolean | null;
    }>;
    updateDashboardWidget(...args: Parameters<DashboardService['updateDashboardWidget']>): Promise<{
        resultCode: string | null;
    }>;
    deleteDashboard(...args: Parameters<DashboardService['deleteDashboard']>): Promise<{
        success: boolean | null;
    }>;
    getAccountInfo(): Promise<{
        accountId: string;
        name?: string;
        subdomain?: string;
    }>;
    getIntegrationDefinitions(...args: Parameters<IntegrationService['getIntegrationDefinitions']>): Promise<{
        definitions: import("../types/jupiterone.js").IntegrationDefinition[];
        pageInfo: {
            endCursor: string;
        };
    }>;
    getIntegrationInstances(...args: Parameters<IntegrationService['getIntegrationInstances']>): Promise<{
        instances: import("../types/jupiterone.js").IntegrationInstanceLite[];
        pageInfo: {
            endCursor: string;
        };
    }>;
    getIntegrationJobs(...args: Parameters<IntegrationService['getIntegrationJobs']>): Promise<{
        jobs: import("../types/jupiterone.js").IntegrationJob[];
        pageInfo: {
            endCursor: string;
        };
    }>;
    /**
     * Get details for a specific integration job
     * @param integrationJobId ID of the job to get
     * @param integrationInstanceId ID of the instance the job belongs to
     */
    getIntegrationJob(integrationJobId: string, integrationInstanceId: string): Promise<import("../types/jupiterone.js").IntegrationJob>;
    /**
     * Get events for a specific integration job
     * @param jobId ID of the job to get events for
     * @param integrationInstanceId ID of the instance the job belongs to
     * @param cursor Optional cursor for pagination
     * @param size Optional size limit for number of events to return
     */
    getIntegrationEvents(jobId: string, integrationInstanceId: string, cursor?: string, size?: number): Promise<{
        events: import("../types/jupiterone.js").IntegrationEvent[];
        pageInfo: {
            endCursor: string;
            hasNextPage: boolean;
        };
    }>;
    executeJ1qlQuery(...args: Parameters<J1qlService['executeJ1qlQuery']>): Promise<any>;
    listEntityTypes(): Promise<any>;
}
//# sourceMappingURL=jupiterone-client.d.ts.map