import { AlChangeStamp } from '@al/core';
import { SourceScope as SourceScope_2 } from '@al/core/assets';

export declare function addPlublicCidr(network: AlAssetManagerNetwork, range: string): AlAssetManagerNetwork;

export declare function addPrivateCidr(network: AlAssetManagerNetwork, range: string): AlAssetManagerNetwork;

export declare interface AlAssetManagerNetwork {
    key?: string;
    network_name?: string;
    cidr_ranges?: string[];
    public_cidr_ranges?: string[];
    span_port_enabled?: boolean;
    network_uuid?: string;
}

export declare const AlAssetsManagerClient: AlAssetsManagerClientInstance;

export declare class AlAssetsManagerClientInstance {
    private readonly serviceName;
    private readonly version;
    constructor();
    getReportSummary(accountId: string, deploymentId: string, qParams: AlAssetsManagerReportSummaryQueryParams): Promise<AlAssetsManagerReportSummary>;
    /**
     * @remarks https://console.product.dev.alertlogic.com/api/assets_manager/#api-Management-CreateNetwork
     */
    createNetwork(accountId: string, deploymentId: string, data: AlAssetManagerNetwork, queryParams?: {
        force_large_network?: boolean;
    }): Promise<AlAssetManagerNetwork>;
    /**
     * @remarks https://console.product.dev.alertlogic.com/api/assets_manager/#api-Management-UpdateNetwork
     */
    modifyNetwork(accountId: string, deploymentId: string, networkUuid: string, data: AlAssetManagerNetwork, queryParams?: {
        force_large_network?: boolean;
    }): Promise<AlAssetManagerNetwork>;
    /**
     *  @remarks https://console.product.dev.alertlogic.com/api/assets_manager/#api-Management-DeleteNetwork
     */
    deleteNetwork(accountId: string, deploymentId: string, networkUuid: string): Promise<void>;
    /**
     * @remarks https://console.product.dev.alertlogic.com/api/assets_manager/#api-Management-CreateSubnet
     */
    createSubnet(accountId: string, deploymentId: string, networkUuid: string, data: AlAssetsManagerSubnet): Promise<AlAssetsManagerSubnet>;
    /**
     * @remarks https://console.product.dev.alertlogic.com/api/assets_manager/#api-Management-UpdateSubnet
     */
    modifySubnet(accountId: string, deploymentId: string, networkUuid: string, subnetUuid: string, data: AlAssetsManagerSubnet): Promise<AlAssetsManagerSubnet>;
    /**
     * @remarks https://console.product.dev.alertlogic.com/api/assets_manager/#api-Management-DeleteSubnet
     */
    deleteSubnet(accountId: string, deploymentId: string, networkUuid: string, subnetUuid: string): Promise<void>;
}

export declare interface AlAssetsManagerReportSummary {
    vpc_count?: number;
    subnet_count?: number;
    region_count?: number;
    host_count?: number;
    deployment_count?: number;
    appliance_count?: number;
    agent_count?: number;
}

export declare interface AlAssetsManagerReportSummaryQueryParams {
    asset_type?: string;
    asset_key?: string;
}

export declare interface AlAssetsManagerSubnet {
    key?: string;
    subnet_name?: string;
    cidr_block?: string;
    network?: string;
}

export declare const AlAssetsQueryClient: AlAssetsQueryClientInstance;

export declare class AlAssetsQueryClientInstance {
    constructor();
    /**
     *  Gets the topology tree for a given deployment and returns a
     *  PhoenixTopologySnapshot describing it.
     *  This endpoint only return assets downto the subnet level.
     * @remarks https://console.cloudinsight.alertlogic.com/api/assets_query/#api-Topology-GetConfigTopology
     */
    getConfigTopologySnapshot(accountId: string, deploymentId: string): Promise<PhoenixTopologySnapshot>;
    /**
     *  Gets the topology tree for a given deployment and returns a
     *  PhoenixTopologySnapshot describing it.
     * This endpoint accepts 2 query parameters, category,
     * which will be used to filter vulnerabilities included in the resulting calculation.
     * ?category=config for configuration issues, ?category=security for security findings and scope,
     * ?scope=true for assets in scope (default behavior), ?category=false for all the asssets.
     * The returned format is the same, so rows are just rows of references to the data section.
     * The resulting threatiness on each asset is a live number based on the category filter applied.
     * If unfiltered (no category is provided) all vulnerabilities are included.
     * There is one *maybe* missing feature at this point,
     * which is the relative-ranked categorization by asset type (i.e. threat_level used for color-coding).
     * @param accountId
     * @param deploymentId
     * @param categories the remediations category. Only security and configuration are allowed for now
     * @param extraAssetTypes extras include (container, sg, load-balancer and image)
     * @param scope true|false to whether return all the assets or just the one in scope.
     * @remarks https://console.cloudinsight.alertlogic.com/api/assets_query/#api-Topology-GetOverviewTopology
     */
    getOverviewTopologySnapshot(accountId: string, deploymentId: string, extraAssetTypes?: string[], categories?: string[], scope?: boolean): Promise<PhoenixTopologySnapshot>;
    /**
     * Get Collection Health
     * GET
     * /remediations/v1/:account_id/health/:asset_type
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/health/agent"
     * asset_type: agent, appliance, network, vpc
     */
    getHealth(accountId: string, assetType: string, queryParams?: CollectionHealthQueryParams): Promise<HealthResponse>;
    /**
     * Get Collection Health Summary
     * GET
     * /remediations/v1/:account_id/health/summary
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/health/summary"
     */
    getHealthSummary(accountId: string, queryParams?: {
        scope?: boolean;
        filter?: string[];
    }): Promise<HealthSummaryResponse>;
    /**
     * Find Asset
     * GET
     * /assets_query/v1/:account_id/find
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/01000001/find?collector_type=agent&uuid=CD7C26C3-FAA1-4AD1-86CB-9628ED1B3327"
     */
    findAsset(accountId: string, queryParams?: {
        uuid: string;
        collector_type?: string;
    }): Promise<FoundAsset>;
    /**
     * Find Asset
     * GET
     * /assets_query/v1/:account_id/find
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/01000001/find?collector_type=agent&uuid=CD7C26C3-FAA1-4AD1-86CB-9628ED1B3327"
     */
    findAssets(accountId: string, queryParams?: FindAssetsRequest): Promise<FoundAsset[]>;
    /**
     * Get Asset Details
     * GET
     * /assets_query/v1/:account_id/details
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/12345678/details?type=host&key=id:i-0fa67ce21528409bc&deployment=aws:1234567890®ion=id:us-east-2"
     */
    getAssetDetails(accountId: string, queryParams?: {
        type?: string;
        key?: string;
        deployment?: string;
        region?: string;
        appliance_uuid?: string;
        ip_address?: string;
        port?: string;
        host_uuid?: string;
    }): Promise<GenericResponse>;
    /**
     * Get Assets for Account
     * GET
     * /assets_query/v1/:account_id/assets
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/01000001/assets"
     */
    getAccountAssets(accountId: string, queryParams?: AssetsQueryParams, clearCache?: boolean): Promise<AssetQueryGeneralResponse>;
    /**
     * Get Assets in Deployment
     * GET
     * /assets_query/v1/:account_id/deployments/:deployment_id/assets
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/01000001/deployments/1C0EFEC8-7DBE-480D-A025-ECC13DE30AD5/assets"
     */
    getDeploymentAssets(accountId: string, deploymentId: string, queryParams?: AssetsQueryParams, clearCache?: boolean): Promise<AssetQueryGeneralResponse>;
    getExposuresSummary(accountId: string, qParams: ExposuresCountSummaryQueryParams): Promise<ExposuresCountSummary>;
    /**
     * Get Tags Summary
     * Get a summary of all tags, with normalized keys, across all deployments. This endpoint should be preferred for use-cases that span deployments, like asset groups.
     * GET
     * /assets_query/v1/:account_id/tags/summary
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/12345678/tags/summary?include_tagged_assets=true"
     */
    getTagsSummary(accountId: string, includeTaggedAssets?: boolean): Promise<TagsSummaryResponse>;
    /**
     * Topology Query
     * GET
     * /assets_query/v1/:account_id/deployments/:deployment_id/topology
     * "https://api.cloudinsight.alertlogic.com/assets_query/v1/19000001/deployments/814C2911-09BB-1005-9916-7831C1BAC182/topology"
     */
    getTopology(accountId: string, deploymentId: string, queryParams?: {
        include_filters?: boolean;
        include_remediations?: boolean;
        disposed?: string;
        extras?: string;
    }): Promise<TopologyResponse>;
    /**
     * Get Assessment Specs
     * GET
     * /remediations/v1/:account_id/deployments/:deployment_id/assessment-specs
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/deployments/347203EF-134C-1005-8499-1289DB15AB31/assessment-specs"
     */
    getAssessmentSpecs(accountId: string, deploymentId: string): Promise<GenericResponse>;
    /**
     * Remediation Items List
     * GET
     * /remediations/v1/:account_id/deployments/:deployment_id/remediation-items-list
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/deployments/347203EF-134C-1005-8499-1289DB15AB31/remediation-items-list"
     */
    getRemediationItemsList(accountId: string, deploymentId: string): Promise<RemediationsItemsListResponse>;
    /**
     * Remediation Items Query
     * GET
     * /remediations/v1/:account_id/deployments/:deployment_id/remediation-items
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/deployments/347203EF-134C-1005-8499-1289DB15AB31/remediation-items"
     */
    getRemediationItems(accountId: string, deploymentId: string): Promise<GenericResponse>;
    /**
     * Complete Remediations
     * PUT
     * /remediations/v1/:account_id/deployments/:deployment_id/remediations
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/deployments/347203EF-134C-1005-8499-1289DB15AB31/remediations"
     * -d '{"operation": "complete_remediations", "remediation_items": ["/al/15000001:814C2911-09BB-1005-9916-7831C1BAC182/remediation-item/0536575B914C32C8A5D28415D02E4545"]}
     */
    completeRemediations(accountId: string, deploymentId: string, remediationData: {
        operation: string;
        remediation_items: string[];
    }): Promise<any>;
    /**
     * Dispose Remediations
     * PUT
     * /assets_query/v2/:account_id/remediations
     * "https://api.cloudinsight.alertlogic.com/assets_query/v2/10000001/remediations"
     * -d '{"operation": "dispose_remediations", "reason": "Acceptable Risk",
     * "comment": "This risk is acceptable", "expires": 0,
     * "remediation_ids": ["ids_upgrade_hardware"], "deployment_ids":["0A2DC25F-5B5A-4A93-9413-1A8D6F87489E"], filters:[]}'
     */
    disposeRemediations(accountId: string, remediationData: {
        deployment_ids?: string[];
        filters: string[] | string[][];
        vulnerability_ids?: string[];
        remediation_ids?: string[];
        reason: string;
        comment: string;
        expires?: number;
        applies_to_specific_assets?: boolean;
        filter_match_mode?: string;
    }): Promise<RemediationsItemsListResponse>;
    /**
     * Uncomplete Remediations
     * PUT
     * /remediations/v1/:account_id/deployments/:deployment_id/remediations
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/deployments/347203EF-134C-1005-8499-1289DB15AB31/remediations"
     * -d '{"operation": "uncomplete_remediations", "remediation_itemss": ["/al/15000001:814C2911-09BB-1005-9916-7831C1BAC182/remediation-item/0536575B914C32C8A5D28415D02E4545"]}
     */
    uncompleteRemediations(accountId: string, deploymentId: string, remediationData: {
        operation: string;
        remediation_items: string[];
    }): Promise<any>;
    /**
     * Undispose Remediations
     * @deprecated use undisposeRemediationItems insetad.
     * DELETE
     * /remediations/v1/:account_id/remediations
     * https://api.cloudinsight.alertlogic.com/remediations/v1/12345678/remediations?remediation_item_ids=0536575B914C32C8A5D28415D02E4545"
     */
    undisposeRemediations(accountId: string, queryParams?: {
        audit_ids?: string;
        deployment_ids?: string;
        remediation_item_ids?: string;
        remediation_ids?: string;
        vulnerability_ids?: string;
    }): Promise<any>;
    undisposeRemediationItems(accountId: string, remediationData: UndisposeRemediationsRequestBody): Promise<RemediationsItemsListResponse>;
    /**
     * Plan Remediations
     * PUT
     * /remediations/v1/:account_id/deployments/:deployment_id/remediations
     * "https://api.cloudinsight.alertlogic.com/remediations/v1/10000001/deployments/347203EF-134C-1005-8499-1289DB15AB31/remediations"
     * -d '{"operation": "plan_remediations",
     *      "filters": ["stuff"],
     *      "user_id": "0987",
     *      "remediations": ["/al/15000001:814C2911-09BB-1005-9916-7831C1BAC182/remediation-item/0536575B914C32C8A5D28415D02E4545"]}
     */
    planRemediations(accountId: string, deploymentId: string, remediationData: {
        operation: string;
        filters: string[];
        user_id: string;
        remediations: string[];
    }): Promise<any>;
    /**
     * Exposures Deployment Summary
     * GET
     * /assets_query/v1/:account_id/exposures/deployment/summary
     * "https://api.cloudinsight.alertlogic.com/assets_query/v2/10000001/exposures/deployment/summary"
     */
    getExposuresDeploymentSummary(accountId: string, queryParams?: ExposureQueryParams): Promise<ExposuresSummary>;
    /**
     * Exposures Query
     * GET
     * /assets_query/v2/:account_id/exposures
     * "https://api.cloudinsight.alertlogic.com/assets_query/v2/10000001/exposures"
     */
    queryExposures(accountId: string, queryParams?: ExposureQueryParams): Promise<ExposuresQueryResponse>;
    /**
     * Remediations Conclude API
     * PUT
     * /assets_query/v2/:account_id/remediations
     * "https://api.cloudinsight.alertlogic.com/assets_query/v2/10000001/remediations"
     *  -d '{"operation": "conclude_remediations", "remediation_ids": ["ids_upgrade_hardware"], "deployment_ids":["0A2DC25F-5B5A-4A93-9413-1A8D6F87489E"], filters:[]}
     */
    concludeRemediations(accountId: string, remediationData: {
        deployment_ids?: string[];
        filters: string[] | string[][];
        vulnerability_ids?: string[];
        remediation_ids?: string[];
        applies_to_specific_assets?: boolean;
        filter_match_mode?: string;
    }): Promise<RemediationsItemsListResponse>;
    /**
     * Query Remediation Items
     * GET
     * /assets_query/v2/:account_id/remediation-items
     * "https://api.cloudinsight.alertlogic.com/assets_query/v2/10000001/remediation-items"
     */
    queryRemediationItems(accountId: string, queryParams?: RemediationItemsQueryParams): Promise<RemediationItemsQueryResponse>;
    /**
     * Create, Delete and Update an asset-group asset based on operation JSON property:
     * {
     *    "operation": "create_asset_group",
     *    "scope" : "user",
     *    ...
     *    }
     *  }
     * property value:
     * Create: operation = create_asset_group,
     * Delete: operation = delete_asset_group,
     * Update: operation = update_asset_group
     *
     * PUT
     * /assets_write/v1/:account_id/assets
     *
     * @param accountId The AIMS Account ID
     * @param payload Notification type object
     * @returns a promise with the asset-group that was created
     *
     * @remarks
     * URL: https://api.product.dev.alertlogic.com/assets_write/v1/01000001/assets
     * API: https://console.account.alertlogic.com/users/api/assets_write/#api-AssetGroupOperations
     */
    assetGroupOperations(accountId: string, payload: AssetGroupPayload): Promise<AssetGroup>;
    /**
     * Get Asset Group Topology
     * POST
     * /assets_query/v1/:account_id/topology/asset_group
     */
    getAssetGroupTopology(accountId: string, requestParams: AssetGroupTopologyQueryParams): Promise<AssetGroupTopologyResponse>;
    /**
     * List Asset Groups
     * GET
     * /assets_query/v1/:account_id/asset_groups
     */
    listAssetGroups(accountId: string): Promise<AssetGroupListResponse>;
    /**
     * Fetches the "schema" for asset types. The schema describes the structure for asset types.
     * GET
     * /asset_query/v1/asset_types
     */
    getAssetTypes(queryParams: {
        filter?: string;
        fields?: string;
        format?: string;
    }): Promise<AssetTypesResponse>;
    /**
     * Delete Asset Group
     * PUT
     * /assets_query/v1/:account_id/asset_groups
     */
    deleteAssetGroup(accountId: string, name: string, dryRun?: boolean): Promise<DeleteAssetGroupResponse>;
    /**
     * Retrieves incident IDs associated with the specified assets.
     * POST
     * /assets_query/v1/:account_id/incident_ids
     * @param {string} accountId - The ID of the account to query.
     * @param {AssetsQueryIncidentIdsPayload} payload - The payload for the request, including the list of assets and limit.
     * @returns {Promise<AssetsQueryIncidentIdsResponse>} - A promise that resolves with an object containing incident IDs by asset.
     */
    getIncidentsIdsByAsset(accountId: string, payload: AssetsQueryIncidentIdsPayload): Promise<AssetsQueryIncidentIdsResponse>;
}

export declare const AlAssetsWriteClient: AlAssetsWriteClientInstance;

export declare class AlAssetsWriteClientInstance {
    private readonly serviceName;
    private readonly serviceVersion;
    constructor();
    /**
     * @remarks https://console.cloudinsight.alertlogic.com/api/assets_write/#api-Declare-CreateNetwork
     */
    createNetwork(accountId: string, deploymentId: string, data: AssetWriteNetworkRequestBody): Promise<{
        key: string;
    }>;
    /**
     * DeclareModify - Declare Asset
     * DeclareModify - Remove Assets
     * DeclareModify - Remove Properties
     * @remarks https://console.cloudinsight.alertlogic.com/api/assets_write/#api-DeclareModify
     */
    declareModifyAsset(accountId: string, deploymentId: string, data: AssetWriteDeclareAssetRequestBody | AssetWriteDeletePropertiesRequestBody): Promise<AssetWriteDeclareAssetResponse>;
}

export declare interface AlAzureAdClient {
    active_directory_id?: string;
    client_id?: string;
    client_secret?: string;
}

export declare interface AlAzureAdUser {
    active_directory_id?: string;
    username?: string;
    password?: string;
}

export declare interface AlAzureCredential {
    id?: string;
    name?: string;
    type?: 'azure_ad_client';
    azure_ad_client?: AlAzureAdClient;
}

export declare const AlAzureExplorerClient: AlAzureExplorerClientInstance;

export declare class AlAzureExplorerClientInstance {
    protected serviceName: string;
    protected serviceVersion: string;
    constructor();
    validateExistingCredentials(accountId: string, environmentId: string): Promise<AlAzureExplorerValidationResponse>;
    validateExternalCredentials(validationParams: AlAzureExplorerValidationParams, accountId?: string): Promise<AlAzureExplorerValidationResponse>;
}

export declare interface AlAzureExplorerCredential {
    id?: string;
    name?: string;
    type?: 'azure_ad_user' | 'azure_ad_client';
    azure_ad_user?: {
        active_directory_id?: string;
        username?: string;
        password?: string;
    };
    azure_ad_client?: {
        active_directory_id?: string;
        client_id?: string;
        client_secret?: string;
    };
    subscription_id?: string;
    credential?: AlAzureCredential;
}

export declare interface AlAzureExplorerValidationParams {
    subscription_id?: string;
    credential?: AlAzureExplorerCredential;
    account_id?: string;
    environment_id?: string;
}

export declare interface AlAzureExplorerValidationResponse {
    status?: string;
    message?: string;
}

export declare const AlDeploymentsClient: AlDeploymentsClientInstance;

export declare class AlDeploymentsClientInstance {
    private serviceName;
    private serviceVersion;
    constructor();
    createDeployment(accountId: string, deploymentRequest: DeploymentCreateBody): Promise<Deployment>;
    updateDeployment(accountId: string, deploymentId: string, deploymentRequest: DeploymentUpdateBody): Promise<Deployment>;
    deleteDeployment(accountId: string, deploymentId: string): Promise<void>;
    getDeployment(accountId: string, deploymentId: string): Promise<Deployment>;
    listDeployments(accountId: string, filters?: {
        [i: string]: string;
    } | string[]): Promise<Deployment[]>;
}

export declare const AlSourcesClient: AlSourcesClientInstance;

export declare class AlSourcesClientInstance {
    private serviceName;
    constructor();
    getSources(accountId: string, filters?: string): Promise<EnvironmentSource[]>;
    getSource(accountId: string, sourceId: string): Promise<EnvironmentSource>;
    createSource(accountId: string, source: EnvironmentSource): Promise<EnvironmentSource>;
    replaceSource(accountId: string, sourceId: string, source: EnvironmentSource): Promise<EnvironmentSource>;
    deleteSource(accountId: string, sourceId: string): Promise<void>;
    deleteAllSources(accountId: string, filters?: string): Promise<void>;
    getCredentials(accountId: string, filters?: string): Promise<EnvironmentCredential[]>;
    getCredential(accountId: string, credentialId: string): Promise<EnvironmentCredential>;
    createCredential(accountId: string, credential: EnvironmentCredential): Promise<EnvironmentCredential>;
    replaceCredential(accountId: string, sourceId: string, credential: EnvironmentCredential): Promise<EnvironmentCredential>;
    deleteCredential(accountId: string, credentialId: string, filters?: string): Promise<void>;
}

export declare const AlVulnerabilitiesClient: AlVulnerabilitiesClientInstance;

export declare class AlVulnerabilitiesClientInstance {
    constructor();
    getRemediation(remediationId: string): Promise<Remediation>;
    getVulnerability(vulnerabilityId: string): Promise<Vulnerability>;
}

export declare class AssetDescriptor {
    type: string;
    key: string;
    name: string;
    parent: AssetDescriptor;
    children: AssetDescriptor[];
    summary: {
        [i: string]: number;
    };
    properties: {
        [property: string]: any;
    };
    dnsName: string;
    state: string;
    operation: string;
    scope: string;
    ipAddress: string;
    constructor();
    static import(rawData: any): AssetDescriptor;
    /**
     *  Retrieves a child AssetDescriptor, identified by key, if this AssetDescriptor has such a child.
     */
    childByKey(key: string): AssetDescriptor;
    /**
     *  The `lineage` iteration method allows the caller to ascend upwards through the topology view, from lowest to highest.
     */
    lineage(iterator: AssetIteratorCallback): void;
    /**
     *  The `iterate` method allows the caller to descend into the topology view from a given asset.
     */
    iterate(iterator: AssetIteratorCallback, typesFilter?: string[]): void;
}

export declare interface AssetGroup {
    key: string;
    account_id: string;
    deployment_id: string;
    properties: Properties;
    relationships: [];
    type: string;
    version: number;
    created_on: number;
    declared: boolean;
    deleted_on: number;
    modified_on: number;
    scopes?: Scope[];
    criticality?: number;
    description?: string;
    created_by: string;
    modified_by: string;
    groups?: string[];
    membership_counts?: {
        [property: string]: number;
    };
}

export declare interface AssetGroupListResponse {
    count: number;
    groups: AssetGroup[];
}

export declare interface AssetGroupPayload {
    key?: string;
    operation?: 'create_asset_group' | "delete_asset_group" | "update_asset_group";
    scope?: string;
    name?: string;
    description?: string;
    properties?: Properties;
    dry_run?: boolean;
    wait_for_operation?: boolean;
}

export declare interface AssetGroupTopology {
    assets: string[][];
    data: {
        [property: string]: TopologyAssetData;
    };
    rows: number;
}

export declare interface AssetGroupTopologyQueryParams {
    scopes: Scope[];
    return_asset_types?: string[];
}

export declare interface AssetGroupTopologyResponse {
    topology: AssetGroupTopology;
}

declare type AssetIteratorCallback = (asset: AssetDescriptor) => boolean;

declare type AssetIteratorCallback_2 = (asset: AssetDescriptor) => boolean;

export declare interface AssetQueryGeneralResponse {
    assets: AssetQueryResultItem[] | AssetQueryResultItem[][];
    rows: number;
}

export declare interface AssetQueryResultItem {
    account_id?: string;
    created_on?: number;
    criticality?: number;
    declared?: boolean;
    deleted_on?: number;
    deployment_id?: string;
    deployment_type?: string;
    description?: string;
    group_id?: string;
    group_name?: string;
    groups?: string[];
    groups_match?: 'any' | 'all';
    in_scope?: boolean;
    key?: string;
    membership_counts?: {
        [property: string]: number;
    };
    modified_on?: number;
    name?: string;
    native_type?: string;
    path?: string[];
    refreshed_on?: number;
    scope_aws_group_description?: string;
    scope_aws_group_id?: string;
    scope_aws_group_name?: string;
    scope_aws_native_id?: string;
    scope_aws_vpc_id?: string;
    scopes?: Scope[];
    statistics?: AssetQueryResultStatistics;
    status?: string;
    statuses?: {
        [i: string]: AssetQueryResultItemStatus;
    };
    tag_keys?: {
        [key: string]: string;
    };
    tags?: {
        [key: string]: string;
    };
    threat_level?: number;
    threatiness?: number;
    type?: string;
    version?: number;
    alertlogic_agent?: boolean;
    related_properties?: unknown;
    alertlogic_appliance?: boolean;
    host_uuid?: string;
    protection_policy_id?: string;
    protection_policy_name?: string;
    /** 0 for healthy and 2 for unhealthy */
    health_level?: 0 | 2;
    /** An object mapping exposure severity to open security exposure count  */
    security_exposure_summary?: {
        total: number;
        critial: number;
        high: number;
        medium: number;
        low: number;
        info: number;
    };
    /** A string containing the highest severity for open security exposures on the asset */
    security_exposure_severity?: 'critial' | 'high' | 'medium' | 'low' | 'info';
    /** A number containing the aggregated threatiness for open security exposures */
    security_threatiness?: number;
    /** An object mapping exposure severity to open health exposure count */
    health_exposure_summary?: {
        total: number;
        medium: number;
        low: number;
        info: number;
        high: number;
        critical: number;
    };
    /** A string containing the highest severity for open health exposures on the asset */
    health_exposure_severity?: 'critial' | 'high' | 'medium' | 'low' | 'info';
    /** A number containing the aggregated threatiness for open health exposures */
    health_threatiness?: number;
    /** Property that exposes what appliance is protecting the host */
    scope_identity_connected_to?: string;
}

export declare interface AssetQueryResultItemStatus {
    type?: string;
    timestamp?: number;
    stream?: string;
    condition?: string;
    application?: string;
    metadata?: {
        [i: string]: unknown;
    };
    reasons?: unknown;
}

export declare interface AssetQueryResultStatistics {
    bytes_ids?: AssetQueryResultStatisticsDetails;
    bytes_log?: AssetQueryResultStatisticsDetails;
    messages_log?: AssetQueryResultStatisticsDetails;
    packets_ids?: AssetQueryResultStatisticsDetails;
}

export declare interface AssetQueryResultStatisticsDetails {
    hours?: unknown;
    last_day?: number;
    last_hour?: number;
}

export declare interface AssetsQueryIncidentIdsPayload {
    assets: {
        deployment_id: string;
        key: string;
        type: string;
    }[];
    limit: number;
}

export declare interface AssetsQueryIncidentIdsResponse {
    [key: string]: string[];
}

export declare interface AssetsQueryParams {
    asset_types?: string;
    return_types?: string;
    query_format?: string;
    return_count?: boolean;
    reduce?: boolean;
    qfields?: string;
    [key: string]: any;
}

export declare interface AssetTag {
    key?: string;
    type?: string;
    deployment_id?: string;
    tags?: {
        [index: string]: string;
        nickname?: string;
    };
}

export declare class AssetTypeDictionary {
    static types: {
        [type: string]: IAssetType;
    };
    /**
     *  @method assetTypeDictionary.getType
     */
    static getType(assetType: string): IAssetType;
    static keyToID: (key: string) => string;
}

declare interface AssetTypesListResponse {
    aliases: string[];
    always_create: boolean;
    always_in_scope: boolean;
    asset_type: string;
    custom_properties: string[];
    groupable: boolean;
    name_property: string[];
    notify_delta_properties: string[];
    promoted_properties: {
        [property: string]: {
            [property: string]: string;
        };
    };
    relationships: {
        [property: string]: string[];
    };
    scope_container: string;
    taggable: boolean;
    topological_ancestors: string[];
    topological_children: string[];
    topological_parent: string;
    topological_successor_paths: string[];
    topological_successors: any;
    topological_successors_list: string[];
    unscoped_properties: string[];
    vulnerable: boolean;
}

declare interface AssetTypesResponse {
    count: number;
    asset_types: AssetTypesListResponse[];
}

export declare interface AssetWriteDeclareAssetRelationship {
    type: string;
    key: string;
    relationship_type?: string;
}

export declare interface AssetWriteDeclareAssetRequestBody {
    operation: 'declare_asset' | 'remove_asset';
    type: string;
    scope: string;
    key: string;
    properties?: {
        [property: string]: any;
    };
    relationships?: AssetWriteDeclareAssetRelationship[];
    exclusive?: string;
    exclusive_types?: string[];
}

export declare interface AssetWriteDeclareAssetResponse {
    account_id: string;
    deployment_id: string;
    key: string;
    type: string;
    relationships?: AssetWriteDeclareAssetRelationship;
    [i: string]: any;
}

export declare interface AssetWriteDeletePropertiesRequestBody {
    operation: 'remove_properties';
    type: string;
    scope: string;
    key: string;
    property_names: string[];
}

export declare interface AssetWriteDeletePropertiesResponse {
    account_id: string;
    deployment_id: string;
    key: string;
    type: string;
}

export declare interface AssetWriteNetworkProperties {
    network_name: string;
    cidr_ranges: string[];
    public_cidr_ranges: string[];
}

export declare interface AssetWriteNetworkRequestBody {
    operation: 'create_network';
    scope: 'datacenter';
    properties?: AssetWriteNetworkProperties;
}

export declare interface BasicVulnerability {
    categories?: string[];
    name?: string;
    severity?: string;
    threat_score?: number;
    type?: string;
    vulnerability_id?: string;
}

declare type CloudDefenderProductIntegrationSettings = {
    enabled: boolean;
    location_id?: string;
};

export declare const CloudExplorerClient: CloudExplorerClient_2;

declare class CloudExplorerClient_2 {
    private client;
    private serviceName;
    /**
     * Get a list of supported AWS Regions
     * GET
     * /cloud_explorer/v1/supported_regions
     * "https://api.cloudinsight.alertlogic.com/cloud_explorer/v1/supported_regions"
     */
    getSupportedRegions(): Promise<SupportedRegionsResponse>;
    /**
     * Get default AWS third-party role policy
     * GET
     * /cloud_explorer/v1/policy/:rule_set
     * "https://api.cloudinsight.alertlogic.com/cloud_explorer/v1/policy/iam"
     * iam, iam_defender, x_account_ct, none
     */
    getRolePolicy(ruleSet: string): Promise<RolePolicyResponse>;
    /**
     * Initiate Environment Discovery
     * POST
     * /cloud_explorer/v1/:account_id/environments/:environment_id/discover[/:service_name[/:resource_type[/:resource_id]]]?:query_parameters
     * "https://api.cloudinsight.alertlogic.com/cloud_explorer/v1/:account_id/environments/:environment_id/discover"
     * service_name: ec2, iam, rds, route53, s3
     * resource_id: subnet, vpc, host
     */
    initiateDiscovery(accountId: string, environmentId: string, serviceName?: string, resourceType?: string, resourceId?: string, queryParams?: {
        region?: string;
        filter?: string;
        sync?: boolean;
    }): Promise<unknown>;
    /**
     * Validate External Environement Credentials
     * POST
     * /cloud_explorer/v1/validate_credentials
     * "https://api.cloudinsight.alertlogic.com/cloud_explorer/v1/validate_credentials"
     * rule_set: iam, iam_defender, x_account_ct, none, readonly
     * -d {"credential": {"name": "Ozone", "iam_role": {"arn": "arn:aws:iam::123456789016:role/outcomes_role", "external_id": "0000-0001", }, "type": "iam_role"} }
     */
    validateExternalCredentials(credentialData: CredentialData, queryParams?: {
        rule_set?: string;
    }): Promise<unknown>;
    /**
     * Validate Stored Environement Credentials
     * POST
     * /cloud_explorer/v1/validate_credentials
     * "/cloud_explorer/v1/:account_id/environments/:environment_id/validate_credentials"
     */
    validateStoredCredentials(accountId: string, environmentId: string): Promise<unknown>;
}

export declare interface CollectionHealthQueryParams {
    scope?: boolean;
    filter?: string[];
    disposed?: 'true' | 'false' | 'all';
    concluded?: 'true' | 'false' | 'all';
}

export declare interface Coverage {
    regions?: TopologyNode[];
    regionsCount?: number;
    regionsByKey?: {
        [i: string]: TopologyNode;
    };
    vpcs?: TopologyNode[];
    vpcsCount?: number;
    vpcsByKey?: {
        [i: string]: TopologyNode;
    };
    subnets?: TopologyNode[];
    subnetsCount?: number;
    subnetsByKey?: {
        [i: string]: TopologyNode;
    };
    hosts?: TopologyNode[];
    hostsCount?: number;
    hostsByKey?: {
        [i: string]: TopologyNode;
    };
}

declare interface CredentialData {
    credential?: {
        name?: string;
        iam_role?: {
            arn?: string;
            external_id?: string;
        };
        type?: string;
    };
}

declare interface DeleteAssetGroupResponse {
    dry_run: boolean;
    operations: {
        operation: string;
        name: string;
    }[];
}

export declare interface Deployment {
    id?: string;
    account_id?: string;
    version?: number;
    name?: string;
    platform?: DeploymentPlatformType;
    mode?: 'manual' | 'readonly' | 'automatic' | 'guided' | 'none';
    enabled?: boolean;
    features?: DeploymentFeatures;
    discover?: boolean;
    scan?: boolean;
    scope?: {
        include?: IncludedAsset[];
        exclude?: ExcludedAsset[];
    };
    cloud_defender?: CloudDefenderProductIntegrationSettings;
    credentials?: DeploymentCredentials[];
    status?: DeploymentStatus;
    created?: UserTimeStamp;
    modified?: UserTimeStamp;
}

export declare interface DeploymentCommonBody {
    mode?: 'manual' | 'readonly' | 'automatic' | 'guided' | 'none';
    enabled?: boolean;
    discover?: boolean;
    scan?: boolean;
    cloud_defender?: CloudDefenderProductIntegrationSettings;
    credentials?: DeploymentCredentials[];
    version?: number;
}

export declare interface DeploymentCreateBody extends DeploymentCommonBody {
    name: string;
    platform: DeploymentPlatformType;
    scope?: {
        include: IncludedAsset[];
        exclude?: ExcludedAsset[];
    };
}

export declare interface DeploymentCredentials {
    id: string;
    purpose: 'discover' | 'x-account-monitor';
    version?: string;
}

export declare interface DeploymentFeatures {
    abs?: FeatureScopeInfo[];
    scan?: FeatureScopeInfo[];
    fim?: FeatureScopeInfo[];
}

declare type DeploymentMonitoringConfiguration = {
    enabled?: boolean;
    ct_install_region?: string;
};

export declare interface DeploymentPlatformType extends PlatformCommonBody {
    type?: 'aws' | 'azure' | 'datacenter' | 'all';
}

declare type DeploymentStatus = {
    status: 'new' | 'ok' | 'warning' | 'error';
    message?: string;
    timestamp?: number;
};

export declare interface DeploymentUpdateBody extends DeploymentCommonBody {
    name?: string;
    platform?: DeploymentPlatformType;
    status?: DeploymentStatus;
    scope?: {
        include?: IncludedAsset[];
        exclude?: ExcludedAsset[];
    };
}

export declare interface EnvironmentCredential {
    credential: {
        name?: string;
        type?: 'iam_role' | 'azure_ad_user' | '';
        iam_role?: {
            arn?: string;
            external_id?: string;
        };
        azure_ad_user?: {
            active_directory_id?: string;
            username?: string;
            password?: string;
        };
        azure_ad_client?: {
            active_directory_id?: string;
            client_id?: string;
            client_secret?: string;
        };
        created?: AlChangeStamp;
        modified?: AlChangeStamp;
    };
}

export declare interface EnvironmentSource {
    source?: {
        id?: string;
        name?: string;
        product_type?: 'outcomes';
        tags?: string[];
        type?: 'environment';
        config?: {
            collection_method?: 'api';
            collection_type?: 'aws' | 'azure';
            deployment_mode?: 'readonly' | 'guided' | 'automatic' | 'none';
            aws?: EnvironmentSourceConfig;
            azure?: EnvironmentSourceConfig;
        };
        created?: AlChangeStamp;
        modified?: AlChangeStamp;
        enabled?: boolean;
        host?: {
            [key: string]: string;
        };
        status?: {
            [key: string]: string;
        };
    };
}

export declare interface EnvironmentSourceConfig {
    account_id?: string;
    credential?: {
        id?: string;
        version?: string;
    };
    discover?: boolean;
    scan?: boolean;
    defender_support?: boolean;
    defender_location_id?: string;
    aux_credentials?: {
        id?: string;
        purpose?: string;
        version?: string;
    };
    scope?: EnvironmentSourceScope;
    subscription_id?: string;
}

export declare interface EnvironmentSourceScope {
    include?: {
        type?: string;
        key?: string;
    }[];
    exclude?: {
        type?: string;
        key?: string;
    }[];
}

export declare interface ExcludedAsset {
    type: 'region' | 'vpc' | 'subnet' | 'host';
    key: string;
}

export declare interface ExposureQueryParams {
    deployment_id?: string;
    details?: boolean;
    basic_details?: boolean;
    filter?: string | string[];
    group?: 'exposure' | 'remediation' | 'asset';
    include_exposures?: boolean;
    include_filters?: boolean;
    include_remediations?: boolean;
    include_remediation_items?: boolean;
    sort?: string;
    limit?: number;
    scope?: boolean;
    concluded?: boolean;
    disposed?: boolean;
}

export declare interface ExposureQueryResultItem {
    account_id?: string;
    asset_count?: number;
    categories?: string[];
    created_on?: number;
    cve?: string;
    cwe?: string;
    cvss_score?: number;
    cvss_vector?: string;
    deployment_id?: string;
    deployment_ids?: string[];
    exposures?: ExposureQueryResultItem[];
    exposures_count?: number;
    external?: boolean;
    modified_on?: number;
    name?: string;
    remediation_count?: number;
    remediation_id?: string;
    remediations?: ExposureRemediationItem[];
    severities?: ThreatSummary;
    severity?: string;
    tags?: any;
    target_asset_type?: string;
    threat_level?: number;
    threat_pct?: number;
    threat_score?: number;
    threat_vector?: string;
    threatiness?: number;
    type?: string;
    vinstances_count?: number;
    vinstances?: ExposureVInstanceItem[];
    vulnerabilities?: ExposureVulnerabilityItem[];
    vulnerability_count?: string;
    vulnerability_id?: string;
}

export declare interface ExposureQueryResults {
    rows?: number;
    assets?: ExposureQueryResultItem[];
}

export declare interface ExposureRemediationItem {
    account_id?: string;
    name?: string;
    remediation_id?: string;
    tags?: any;
    target_asset_type?: string;
    threat_level?: number;
    threatiness?: number;
    type?: string;
}

export declare interface ExposuresCountSummary {
    summary: {
        severities: ExposureSeverities;
    };
    remediations: {
        rows: number;
        assets: ExposuresSummaryRemediation[];
    };
    filters: unknown[];
}

export declare interface ExposuresCountSummaryQueryParams {
    scope?: boolean;
    include_filters?: boolean;
    include_remediations?: boolean;
    filter?: string[];
    deployment_id?: string;
    details?: boolean;
}

export declare interface ExposuresDeploymentSummary {
    account_id: string;
    asset_count: number;
    deployment_id: string;
    key: string;
    name: string;
    p90_severity: number;
    raw_severity: number;
    severity: number;
    summary: ThreatSummary;
    threatiness: number;
    tri: number;
    type: string;
}

export declare interface ExposureSeverities {
    critical: number;
    medium: number;
    low: number;
    info: number;
    high: number;
    all: number;
}

export declare interface ExposuresQueryFilter {
    account_id?: string;
    deployment_id?: string;
    deployment_name?: string;
    key?: string;
    name?: string;
    threat_level?: number;
    threatiness?: number;
    type?: string;
    vinstances_count?: number;
}

export declare interface ExposuresQueryResponse {
    summary?: {
        severities?: ThreatSummary;
    };
    filters?: ExposuresQueryFilter[];
    exposures?: ExposureQueryResults;
    remediations?: ExposureQueryResults;
}

export declare interface ExposuresSummary {
    exposures: ExposuresDeploymentSummary[];
    summary: ThreatSummary;
}

export declare interface ExposuresSummaryExposure {
    vinstances_count?: number;
    threatiness?: number;
    severity?: string;
    name?: string;
    categories?: string[];
    asset_count?: number;
    vinstances?: ExposuresSummaryVInstance[];
    type: 'vulnerability';
    vulnerability_id: string;
}

export declare interface ExposuresSummaryRemediation {
    vinstances_count?: number;
    threatiness?: number;
    severities?: ExposureSeverities;
    name?: string;
    exposures_count?: number;
    exposures?: ExposuresSummaryExposure;
    remediation_id: string;
    type: 'remediation';
}

export declare interface ExposuresSummaryVInstance {
    threatiness?: number;
    target?: {
        key?: string;
        type: string;
        threatiness: number;
    };
    key: string;
}

export declare interface ExposureVInstanceItem {
    categories?: string[];
    concluded?: boolean;
    details?: string;
    disposed?: boolean;
    key?: string;
    modified_on?: number;
    remediation_item_id?: string;
    target?: ExposureVInstanceTarget;
    threatiness?: number;
}

export declare interface ExposureVInstanceTarget {
    account_id?: string;
    deployment_id?: string;
    dns_name?: string;
    key?: string;
    name?: string;
    scheme?: string;
    tags?: any;
    threat_level?: number;
    threatiness?: number;
    type?: string;
    created_on?: number;
    modified_on?: number;
}

export declare interface ExposureVulnerabilityItem {
    account_id?: string;
    asset_count?: number;
    categories?: string[];
    cvss_score?: number;
    external?: boolean;
    name?: string;
    remediation_id?: string;
    severity?: string;
    tags?: any;
    threat_level?: number;
    threat_score?: number;
    threatiness?: number;
    type?: string;
    vulnerability_id?: string;
}

export declare interface FeatureScopeInfo {
    scope?: ScopeInfo[];
}

export declare interface FindAssetParams {
    uuid: string;
    collector_type?: string;
}

export declare interface FindAssetsRequest {
    parameters?: FindAssetParams[];
}

export declare interface FoundAsset {
    type?: string;
    key?: string;
    deployment_id?: string;
    host_key?: string;
    [key: string]: string;
}

export declare type GenericResponse = {
    [key: string]: unknown;
};

export declare interface Group {
    key: string;
    caption: string;
}

export declare interface HealthAssetAgent {
    account_id: string;
    agent_name?: string;
    created_on?: number;
    declared?: boolean;
    deleted_on?: number;
    deployment_id?: string;
    host_uuid?: string;
    key?: string;
    modified_on?: number;
    name?: string;
    native_type?: string;
    refreshed_on?: number;
    scope_identity_agent_name?: string;
    scope_identity_assigned_to: string;
    scope_identity_connected_to: string;
    scope_identity_host_uuid?: string;
    statistics?: {
        bytes_id?: HealthAssetStatisticCounts;
        bytes_log?: HealthAssetStatisticCounts;
        messages_log?: HealthAssetStatisticCounts;
        packet_ids?: HealthAssetStatisticCounts;
    };
    status?: string;
    status_updated?: number;
    statuses?: {
        [key: string]: {
            application?: string;
            condition?: string;
            reasons?: {
                [key: string]: {
                    text?: string;
                };
            };
            stream?: string;
            timestamp?: number;
            type?: string;
        };
    };
    threat_level?: number;
    threatiness?: number;
    type?: string;
    version?: number;
}

export declare interface HealthAssetAppliance {
    account_id?: string;
    deployment_id?: string;
    key?: string;
    name?: string;
    remediation_id?: string;
    tags?: {
        [key: string]: string;
    };
    target_assset_type?: string;
    threat_level?: number;
    threatiness?: number;
    type?: string;
    created_on?: number;
    modified_on?: number;
}

export declare interface HealthAssetCategory {
    key?: string;
    type?: string;
}

export declare interface HealthAssetCollector {
    name?: string;
    key?: string;
    type?: string;
    created_on?: number;
    modified_on?: number;
    collector_uuid?: string;
    collector_type?: string;
    collector_datatype?: string;
    collector_platform?: string;
    collector_platform_id?: string;
    collector_region?: string;
    collector_name?: string;
    collector_fullname?: string;
    application?: string;
    application_id?: string;
    native_id?: string;
    status?: string;
    status_updated?: string;
}

export declare interface HealthAssetDeployment {
    account_id?: string;
    created_on?: number;
    daily_tri?: number;
    daily_tri_asset_count?: number;
    daily_tri_last_updated?: number;
    daily_tri_pctile_all?: number;
    daily_tri_pctile_segment?: number;
    daily_tri_severity?: number;
    daily_tri_trend_1w?: number;
    daily_tri_trend_4w?: number;
    daily_tri_trend_13w?: number;
    declared?: boolean;
    deleted_on?: number;
    deployment_id?: string;
    deployment_name?: string;
    deployment_type?: string;
    environment_name?: string;
    environment_type?: string;
    key?: string;
    modified_on?: number;
    name?: string;
    native_type?: string;
    path?: string[];
    scope_datacenter_deployment_id?: string;
    scope_datacenter_deployment_type?: string;
    scope_datacenter_environment_id?: string;
    scope_datacenter_environment_type?: string;
    scope_internal_deployment_id?: string;
    scope_internal_deployment_type?: string;
    scope_internal_environment_id?: string;
    scope_internal_environment_type?: string;
    scope_scores_daily_tri?: number;
    scope_scores_daily_tri_asset_count?: number;
    scope_scores_daily_tri_last_updated?: number;
    scope_scores_daily_tri_pctile_all?: number;
    scope_scores_daily_tri_pctile_segment?: number;
    scope_scores_daily_tri_severity?: number;
    scope_scores_daily_tri_trend_1w?: number;
    scope_scores_daily_tri_trend_4w?: number;
    scope_scores_daily_tri_trend_13w?: number;
    threat_level?: number;
    threatiness?: number;
    type?: string;
    version?: number;
}

export declare interface HealthAssetDeploymentType {
    key?: string;
    type?: string;
}

export declare interface HealthAssetExposure {
    account_id?: string;
    categories?: string[];
    created_on: number;
    cvss_score: number;
    cvss_vector: string;
    external: boolean;
    name: string;
    remediation_id: string;
    severity: string;
    threat_score: number;
    threat_vector: string;
    threatiness: number;
    type: string;
    vulnerability_id: string;
}

export declare interface HealthAssetHealthLevel {
    key?: number;
    type?: string;
}

export declare interface HealthAssetHost {
    account_id?: string;
    alertlogic_appliance?: boolean;
    deployment_id?: string;
    dns_name?: string;
    health_level?: number;
    instance_id?: string;
    instance_name?: string;
    instance_type?: string;
    ip_address?: string;
    key?: string;
    name?: string;
    private_dns_name?: string;
    private_ip_address?: string;
    private_ip_addresses?: string[];
    private_ipv4_addresses?: string[];
    private_ipv6_addresses?: string[];
    public_ip_addresses?: string[];
    public_ipv4_addresses?: string[];
    public_ipv6_addresses?: string[];
    local_ipv6?: string[];
    local_ipv4?: string[];
    last_scan_time?: number;
    launch_time?: number;
    architecture?: string;
    availability_zone?: string;
    state?: string;
    tags?: {
        [key: string]: string;
    };
    threat_level?: number;
    threatiness?: number;
    type?: string;
    unhealthiness?: number;
    created_on?: number;
    modified_on?: number;
}

export declare interface HealthAssetImage {
    account_id?: string;
    created_on?: number;
    deployment_id?: string;
    key?: string;
    modified_on?: number;
    threat_level?: number;
    threatiness?: number;
    type?: string;
}

export declare interface HealthAssetProtectionPolicy {
    key?: string;
    type?: string;
}

export declare interface HealthAssetRegion {
    account_id?: string;
    created_on?: number;
    modified_on?: number;
    key?: string;
    deployment_id?: string;
    name?: string;
    region_name?: string;
    type?: string;
    threat_level?: number;
    threatiness?: number;
}

export declare interface HealthAssetRemediation {
    account_id?: string;
    appliance_name?: string;
    remediation_id?: string;
    created_on?: number;
    declared?: boolean;
    deleted_on?: number;
    deployment_id?: string;
    host_uuid?: string;
    key?: string;
    load_indicator?: number;
    modified_on?: number;
    name?: string;
    native_type?: string;
    scope_agent_load_indicator?: number;
    scope_agent_load_indicator_update_ts?: number;
    scope_identity_appliance_name?: string;
    scope_identity_host_uuid?: string;
    tags?: {
        [key: string]: string;
    };
    threat_level?: number;
    threatiness?: number;
    type?: string;
    version?: number;
}

export declare interface HealthAssetStatisticCounts {
    last_hour?: number;
    last_day?: number;
    hours?: {
        [key: string]: number;
    };
}

export declare interface HealthAssetSubnet {
    account_id?: string;
    created_on?: number;
    modified_on?: number;
    key?: string;
    deployment_id?: string;
    name?: string;
    subnet_id?: string;
    subnet_name?: string;
    subnet_uuid?: string;
    cidr_block?: string;
    type?: string;
    threat_level?: number;
    threatiness?: number;
    state?: string;
}

export declare interface HealthAssetVPC {
    account_id?: string;
    cidr_ranges?: string[];
    deployment_id?: string;
    health_level?: number;
    key?: string;
    name?: string;
    state?: string;
    network_uuid?: string;
    tags?: {
        [key: string]: string;
    };
    threat_level?: number;
    threatiness?: number;
    type?: string;
    unhealthiness?: number;
    vpc_id?: string;
    vpc_name?: string;
    created_on?: number;
    modified_on?: number;
}

export declare interface HealthCoverage {
    protected?: number;
    total?: number;
}

export declare interface HealthListItem {
    agent?: string;
    appliance?: string;
    asset_count?: number;
    collector?: string;
    deployment?: string;
    exposures?: HealthListItemExposure[];
    exposures_by_remediation?: {
        [remediationKey: string]: string[];
    };
    exposures_count?: number;
    health_level?: number;
    host?: string;
    protection_policy_id?: string;
    region?: string;
    remediations?: string[];
    remediations_filters?: string[];
    unhealthiness?: number;
    vpc?: string;
    subnet?: string;
    image?: string;
}

export declare interface HealthListItemExposure {
    asset_count?: number;
    exposure?: string;
}

export declare interface HealthResponse {
    assets?: {
        [key: string]: HealthAssetVPC | HealthAssetRemediation | HealthAssetDeployment | HealthAssetAppliance | HealthAssetAgent | HealthAssetHost | HealthAssetCollector;
    };
    filters?: HealthResponseFilters;
    list?: HealthListItem[];
}

export declare interface HealthResponseFilters {
    [key: string]: {
        count?: number;
        health_level?: number;
        healthiness?: number;
    };
}

export declare interface HealthScore {
    count?: number;
    health_level?: number;
    unhealthiness?: number;
}

export declare interface HealthScores {
    scores?: HealthScore[];
}

export declare interface HealthSummaryResponse {
    agents?: {
        coverage?: HealthCoverage;
        health?: HealthScores;
    };
    appliances?: {
        coverage?: HealthCoverage;
        health?: HealthScores;
    };
    networks?: {
        coverage?: HealthCoverage;
        health?: HealthScores;
    };
    collectors?: {
        coverage?: HealthCoverage;
        health?: HealthScores;
    };
}

export declare interface IAssetType {
    type: string;
    caption: string;
    topological: boolean;
    pluralCaption?: string;
    icon?: string;
    iconMt?: string;
    debbug?: boolean;
    format?: string;
    types?: Array<string>;
    renderName?(asset: any): string;
    getAssetDetails?(asset: any): any;
    renderDescription?(asset: any): string;
    getSetName?(asset: any): string;
    renderID?(asset: any): string;
    transform?(value: any, assetParam?: any, key?: any): any;
}

export declare interface IncludedAsset {
    type: 'deployment' | 'region' | 'vpc' | 'subnet' | 'host';
    key: string;
    policy?: {
        id: string;
    };
}

export declare function newNetwork(): AlAssetManagerNetwork;

export declare function newSubnet(): AlAssetsManagerSubnet;

declare type NodeIteratorCallback = (asset: TopologyNode) => boolean;

declare type NodeIteratorCallback_2 = (asset: TopologyNode) => boolean;

export declare class PhoenixTopologySnapshot {
    static extraAssetTypes: string[];
    regions: TopologyNode[];
    vpcs: TopologyNode[];
    subnets: TopologyNode[];
    hosts: TopologyNode[];
    extras: {
        [key: string]: TopologyNode[];
    };
    deploymentMode: string;
    deploymentId: string;
    summary: {
        [i: string]: number;
    };
    private assetsByKey;
    private hostsByUuid;
    constructor();
    /**
     *  @method PhoenixTopologySnapshot.import
     *
     *  A static method to convert tabular assets data into a tree structure.
     *  This method expects to receive the raw object response from asset-query's topology endpoint
     *  https://console.product.dev.alertlogic.com/api/assets_query/index.html#api-Queries-Topology_Query
     *  It returns a populated instance of type TopologySnapshot.
     */
    static import(rawData: any): PhoenixTopologySnapshot;
    static calculateSummary(assetCounts: any): {
        [i: string]: number;
    };
    /**
     *  Gets any node in the tree, identified by key
     */
    getByKey(key: string): TopologyNode | null;
    deleteByKey(key: string): void;
    getByHostUuid(hostUuid: string): TopologyNode | null;
    /**
     *  Inserts an TopologyNode into the asset tree, appending it to the top level
     *  region & vpc lists if it is a region or vpc and adding it to a parent node if one is provided.
     */
    add(asset: TopologyNode, parent?: TopologyNode, isExtra?: boolean): TopologyNode;
    /**
     *  @method PhoenixTopologySnapshot.iterate
     *
     *  @param {NodeIteratorCallback} iterator The callback method to be applied to each asset.
     *  @param {Array} typesFilter An option list of asset types that the iteration should be limited to.
     *
     *  Iterates through all of the assets in the topology snapshot, from the top level regions downward.
     *  Regions are assumed to be an allowed type, regardless of whether or not they are present in typesFilter.
     *
     */
    iterate(iterator: NodeIteratorCallback_2, typesFilter?: string[]): void;
    /**
     *  @method PhoenixTopologySnapshot.getSummary
     *
     *  @param {Array<string>} assetTypes
     *  @param {TopologyNode} startNode optional starting node
     *  @param {EnvironmentSourceScope} scope optional scope
     *
     *  This return dicionary with the assets count summary
     *
     */
    getSummary(assetTypes?: string[], startNodeKey?: string, scope?: SourceScope_2): {
        [i: string]: number;
    };
    getCoverage(scope: SourceScope_2, deploymentMode?: string, deploymentType?: string): Coverage;
    /**
     * @method PhoenixTopologySnapshot.getAllAssets
     *
     */
    getAllAssets(): TopologyAssetsSummary;
    private isAlSecurity;
}

export declare interface PlatformCommonBody {
    id?: string;
    monitor?: DeploymentMonitoringConfiguration;
    default?: boolean;
}

export declare function privateCidrExists(network: AlAssetManagerNetwork, range: string): boolean;

export declare interface Properties {
    scopes?: Scope[];
    tags?: Tag[];
    groups?: string[];
    groups_match?: 'all' | 'any';
    description?: string;
    criticality?: number;
}

export declare function publicCidrExists(network: AlAssetManagerNetwork, range: string): boolean;

export declare interface Remediation {
    name: string;
    id: string;
    description: string;
    vulnerability_ids: string[];
}

export declare interface RemediationItemAsset {
    account_id?: string;
    applies_to_specific_assets?: boolean;
    asset_count?: number;
    audit_id?: string;
    created_on?: number;
    deployment_id?: string;
    deployment_ids?: string[];
    comment?: string;
    expires?: number;
    exposures?: ExposureQueryResultItem[];
    exposures_count?: number;
    filter_match_mode?: string;
    filters?: string[];
    item_id?: string;
    item_ids?: string[];
    key?: string;
    keys?: string[];
    modified_on?: number;
    reason?: string;
    remediation?: {
        account_id?: number;
        categories?: string[];
        created_on?: number;
        deployment_id?: string;
        key?: string;
        modified_on?: number;
        name?: string;
        remediation_id?: string;
        tags: any;
        target_asset_type?: string;
        threat_level?: number;
        threatiness?: number;
        type?: string;
    };
    remediation_id?: string;
    severities?: ThreatSummary;
    state?: string;
    tags?: any;
    threat_level?: number;
    threatiness?: number;
    type?: string;
    user_id?: string;
    vinstances_count?: number;
    vulnerability_id?: string;
    vulnerability?: BasicVulnerability;
}

export declare interface RemediationItemsFilter {
    type: string;
    name: string;
    key: string;
    count: number;
}

export declare interface RemediationItemsQueryParams {
    deployment_ids?: string;
    remediation_item_ids?: string;
    state?: string;
    filter?: string | string[];
    include_exposures?: boolean;
    include_filters?: boolean;
    detailed_filters?: boolean;
    details?: boolean;
    group_by_audit_id?: boolean;
    audit_ids?: string;
    remediation_ids?: string;
    vulnerability_ids?: string;
    basic_details?: boolean;
}

export declare interface RemediationItemsQueryResponse {
    filters?: string[] | RemediationItemsFilter[];
    'remediation-items'?: RemediationItemsQueryResult;
    summary?: {
        severities?: ThreatSummary;
    };
}

export declare interface RemediationItemsQueryResult {
    assets?: RemediationItemAsset[];
    rows?: number;
}

export declare interface RemediationsItemsListResponse {
    assets?: GenericResponse[];
    rows?: number;
}

export declare function removePrivateCidr(network: AlAssetManagerNetwork, range: string): AlAssetManagerNetwork;

export declare function removePublicCidr(network: AlAssetManagerNetwork, range: string): AlAssetManagerNetwork;

declare interface RolePolicyResponse {
    type?: string;
    aws_account_id?: string;
    document?: any;
    version?: string;
}

export declare interface Scope {
    include?: string[];
    exclude?: string[];
    asset_types?: string[];
}

export declare interface ScopeDescriptor {
    key?: string;
    type?: string;
}

export declare interface ScopeInfo {
    type: 'deployment' | 'region' | 'vpc' | 'subnet' | 'host';
    key: string;
}

/**
 * Performs the search of assets matching a string against fields: key, name and description.
 *
 * This function traverses the topology set to find assets matching a search phrase,
 * optionally limiting to visible elements, and applies a callback to *each* corresponding graph node.
 * @param {PhoenixTopologySnapshot} topology The topology data
 * @param {string} selectedRegionKey the asset key of a region item in topology (set as undefined it there is not one)
 * @param {string} searchPhrase text to do to pattern matching with.
 * @param {boolean} includeInvisibleItems is a flag to tell whether include un-scoped and filtered assets or not
 * @param {Array<string>} extraProperties additional properities to to trye to match. Default are the IP address-related ones.
 * @returns { { [key: string]: TopologyNode }} the  assets found.
 */
export declare function search(topology: PhoenixTopologySnapshot, selectedRegionKey: string, searchPhrase: string, includeInvisibleItems: boolean, extraProperties?: string[]): {
    [key: string]: TopologyNode;
};

export declare interface SourceScope {
    scopeInclude?: ScopeDescriptor[];
    scopeExclude?: ScopeDescriptor[];
    scopeIncludeByKey?: {
        [key: string]: ScopeDescriptor;
    };
    scopeExcludeByKey?: {
        [key: string]: ScopeDescriptor;
    };
}

/**
 *  A class to manage a full source representation and provide structured access to its data.
 */
export declare class SourceSnapshot {
    source: EnvironmentSource;
    sourceByKey: {
        [key: string]: EnvironmentSource;
    };
    constructor();
    /**
     *  @method SourceSnapshot.import
     *
     *  It returns a populated instance of type SourceSnapshot.
     */
    static import(rawData: EnvironmentSource): SourceSnapshot;
    /**
     *  Gets any node in the tree, identified by key
     */
    getScope(provider?: string): SourceScope | null;
    /**
     * Inserts an SourceDescriptor into the source object
     */
    add(source: EnvironmentSource): EnvironmentSource;
}

declare interface SupportedRegionsResponse {
    regions?: string[];
}

export declare interface Tag {
    key: string;
    value: any;
    groups?: string[];
}

export declare interface TaggedAssetData {
    deployment_ids?: string[];
    key: string;
    name: string;
    tag_key?: string;
    tag_value?: string;
    type: string;
}

export declare interface TagsSummaryResponse {
    tags?: {
        assets: string[][];
        rows: number;
        data: {
            [key: string]: TaggedAssetData;
        };
    };
}

export declare interface ThreatSummary {
    all?: number;
    high?: number;
    info?: number;
    low?: number;
    medium?: number;
}

export declare interface TopologyAssetData {
    account_id?: string;
    alertlogic_appliance?: boolean;
    architecture?: string;
    availability_zone?: string;
    cidr_block?: string;
    created_on?: number;
    deployment_id?: string;
    dns_name?: string;
    groups?: string[];
    group_name?: string;
    group_membership?: string;
    group_id?: string;
    instance_id?: string;
    instance_name?: string;
    instance_type?: string;
    ip_address?: string;
    key?: string;
    launch_time?: number;
    membership_counts?: {
        [property: string]: {
            in?: number;
            not_in?: number;
        };
    };
    modified_on?: number;
    name?: string;
    native_type?: string;
    private_dns_name?: string;
    private_ip_address?: string;
    private_ip_addresses?: string[];
    private_ipv4_addresses?: string[];
    private_ipv6_addresses?: string[];
    public_ip_addresses?: string;
    public_ipv4_addresses?: string[];
    public_ipv6_addresses?: string[];
    state?: string;
    subnet_id?: string;
    subnet_name?: string;
    subnet_uuid?: string;
    tags?: {
        [property: string]: string;
    };
    type?: string;
}

export declare interface TopologyAssetsSummary {
    regions: TopologyNode[];
    vpcs: TopologyNode[];
    subnets: TopologyNode[];
    hosts: TopologyNode[];
    regionsCount: number;
    vpcsCount: number;
    subnetsCount: number;
    hostsCount: number;
}

export declare class TopologyNode extends AssetDescriptor {
    children: TopologyNode[];
    parent: TopologyNode | null;
    /** UI properties */
    excluded: boolean;
    matched: boolean;
    links: TopologyNodeLink[];
    flavor: string;
    remediationsThreatLevel: any;
    securityRemediations: boolean;
    configurationRemediations: boolean;
    incidentsThreatLevel: any;
    expediteScanPending: boolean;
    lastScan: any;
    scanInProgress: boolean;
    hasCredentials: boolean;
    peeredFrom: TopologyNode[];
    peeredTo: TopologyNode | null;
    deploymentName?: string;
    hasVpcId: boolean;
    selected: boolean;
    deploymentId: string;
    stoppedInstance: boolean;
    nodeId: string;
    focused: boolean;
    guided: boolean;
    saved: boolean;
    vpcCount: number;
    coveredVpcCount: number;
    subnetCount: number;
    static import(rawData: any): TopologyNode;
    /**
     *  Retrieves a child AssetDescriptor, identified by key, if this AssetDescriptor has such a child.
     */
    childByKey(key: string): TopologyNode;
    /**
     *  The `lineage` iteration method allows the caller to ascend upwards through the topology view, from lowest to highest.
     */
    lineage(iterator: NodeIteratorCallback): void;
    /**
     *  The `iterate` method allows the caller to descend into the topology view from a given asset.
     */
    iterate(iterator: NodeIteratorCallback, typesFilter?: string[]): void;
}

export declare interface TopologyNodeLink {
    source: TopologyNode;
    target: TopologyNode;
}

export declare interface TopologyResponse {
    topology?: {
        assets?: any;
        rows?: number;
    };
    extras?: any;
    image?: any;
}

export declare class TopologySnapshot {
    static extraAssetTypes: string[];
    regions: AssetDescriptor[];
    vpcs: AssetDescriptor[];
    extras: {
        [key: string]: AssetDescriptor[];
    };
    assetsByKey: {
        [key: string]: AssetDescriptor;
    };
    deployment_mode: string;
    constructor();
    /**
     *  @method TopologySnapshot.import
     *
     *  A static method to convert tabular assets data into a tree structure.
     *  This method expects to receive the raw object response from asset's topology endpoint
     *  https://console.cloudinsight.alertlogic.com/api/assets/#api-Assets_Queries-Topology_Query
     *  It returns a populated instance of type TopologySnapshot.
     */
    static import(rawData: any): TopologySnapshot;
    /**
     *  Gets any node in the tree, identified by key
     */
    getByKey(key: string): AssetDescriptor;
    /**
     *  Inserts an AssetDescriptor into the asset tree, appending it to the top level
     *  region & vpc lists if it is a region or vpc and adding it to a parent node if one is provided.
     */
    add(asset: AssetDescriptor, parent?: AssetDescriptor): AssetDescriptor;
    /**
     *  @method TopologySnapshot.iterate
     *
     *  @param {AssetIteratorCallback} iterator The callback method to be applied to each asset.
     *  @param {Array} typesFilter An option list of asset types that the iteration should be limited to.
     *
     *  Iterates through all of the assets in the topology snapshot, from the top level regions downward.
     *  Regions are assumed to be an allowed type, regardless of whether or not they are present in typesFilter.
     *
     */
    iterate(iterator: AssetIteratorCallback_2, typesFilter?: string[]): void;
    /**
     *  @method TopologySnapshot.getSummary
     *
     *  @param {AssetDescriptor} asset The object asset
     *
     *  This return array with the assets count summary
     *  It just support regions and vpcs
     *
     */
    getSummary(asset: AssetDescriptor, scope: any): any;
    /**
     * @method TopologySnapshot.getCoverage
     *
     * @param scope
     */
    getCoverage(scope: any, deploymentMode?: string): any;
    /**
     * @method TopologySnapshot.getAllAssets
     *
     * @param scope
     */
    getAllAssets(): any;
}

export declare interface UndisposeRemediationsRequestBody {
    operation?: string;
    filters?: string[];
    audit_ids?: string[];
    deployment_ids?: string[];
    vulnerability_ids?: string[];
    remediation_ids?: string[];
    remediation_item_ids?: string[];
}

declare interface UserTimeStamp {
    by: string;
    at: number;
}

export declare interface Vulnerability {
    class?: string;
    cve?: string[];
    cvss_score?: number;
    cvss_vector?: string;
    cvss_version?: string;
    cwe?: string;
    cwe_name?: string;
    cwe_type?: string;
    cwe_url?: string;
    description?: string;
    exposure_id?: string;
    full_description?: string;
    id: string;
    impact?: string;
    pci_severity?: string;
    reference?: string;
    remediation_id?: string;
    resolution?: string;
    scores?: VulnerabilityScore[];
    severity?: string;
}

export declare interface VulnerabilityScore {
    score?: number;
    severity?: string;
    vector?: string;
    version?: string;
}

export { }
