import { AlApiClient } from '@al/core';
import { AlChangeStamp } from '@al/core';

export declare interface AlApplication extends AlBaseApplication {
    name: string;
    enabled?: boolean;
    description?: string[];
    form: AlFormApplication;
    properties?: {
        [i: string]: any;
    };
}

export declare interface AlApplicationAttribute {
    name: string;
    id: string;
    parent_categories?: string[];
    type?: string;
    properties?: AlApplicationProperties;
}

export declare interface AlApplicationAutomaticFilename {
    type?: 'automatic';
    pattern?: string;
}

export declare interface AlApplicationConfig {
    syslog?: AlApplicationSyslog;
    flatfile?: AlApplicationFlatfile;
    eventlog?: AlApplicationEventlog;
}

export declare interface AlApplicationConfigQuery {
    attributes?: string;
}

export declare interface AlApplicationCounterFilename {
    type?: 'counter';
    pattern?: string;
    format?: 'increasing' | 'decreasing';
}

export declare interface AlApplicationDatetimeFilename {
    type?: 'datetime';
    pattern?: string;
    format: string;
}

export declare interface AlApplicationEventlog {
    collect_from_discovered_streams?: boolean;
    og_api_request_size?: number;
    streams?: string[];
}

export declare interface AlApplicationFlatfile {
    path?: string;
    message_timestamp?: AlApplicationMessageTimestamp;
    message_split_spec?: AlApplicationMessageSplitSpecSingleLine | AlApplicationMessageSplitSpecCountMessage | AlApplicationMessageSplitSpecMultiline;
    filename: AlApplicationDatetimeFilename | AlApplicationCounterFilename | AlApplicationAutomaticFilename;
}

export declare interface AlApplicationMessageSplitSpecCountMessage {
    type: "fixed_lines_count";
    value: number;
}

export declare interface AlApplicationMessageSplitSpecMultiline {
    type: "multiline_pattern";
    pattern: {
        type: "string" | "regex";
        value: string;
    };
    match_mode: "begins" | "contains" | "ends";
}

export declare interface AlApplicationMessageSplitSpecSingleLine {
    type: "single_line";
}

export declare interface AlApplicationMessageTimestamp {
    type?: "automatic" | "datetime";
    format?: string;
}

declare type AlApplicationProperties = {
    [key: string]: number | string | boolean | AlApplicationProperties;
};

export declare const AlApplicationsClient: AlApplicationsClientInstance;

export declare class AlApplicationsClientInstance {
    protected serviceName: string;
    protected serviceVersion: string;
    constructor();
    /**
     * Return the catalog of application definitions with their default log collection configuration
     * GET
     * /applications/v1/:account_id/applications
     * "https://api.product.dev.alertlogic.com/applications/v1/01000001/applications"
     *
     *  @param accountId AIMS Account ID
     *  @returns a promise with the applications list
     *
     *  @remarks
     *  https://console.product.dev.alertlogic.com/api/applications/#api-Applications-ListApplications
     */
    getAllApplications(accountId: string, queryParams?: AlApplicationConfigQuery): Promise<AlApplication[]>;
    /**
     * Creates a new log collection rule. All omitted properties will be derived from the application definition.
     * POST
     * /applications/v1/:account_id/rules
     * "https://api.product.dev.alertlogic.com/applications/v1/01000001/rules"
     *
     * @param accountId AIMS Account ID
     * @param data The application log rule request body
     * @returns a promise with the subscriptions
     *
     * @remarks
     * https://console.product.dev.alertlogic.com/api/applications/#api-Rules-PostRules
     */
    addRule(accountId: string, data: AlRulePayload, deploymentId?: string): Promise<AlRule>;
    /**
     * Return the log collection rule
     * GET
     * /applications/v1/:account_id/rules/:rule_id
     * "https://api.product.dev.alertlogic.com/applications/v1/01000001/rules/0C51E404-4BB4-4228-B6B7-32B43029C76F"
     *
     * @param accountId AIMS Account ID
     * @param ruleId Rule identifier
     * @returns a promise with the log collection rule
     *
     * @remarks
     * https://console.product.dev.alertlogic.com/api/applications/#api-Rules-GetRule
     */
    getRule(accountId: string, ruleId: string): Promise<AlRule>;
    /**
     * Return the list of log collection rules
     * GET
     * /applications/v1/:account_id/rules
     * "https://api.product.dev.alertlogic.com/applications/v1/01000001/rules"
     *
     *  @param accountId AIMS Account ID
     *  @returns a promise with the rules list
     *
     *  @remarks
     *  https://console.product.dev.alertlogic.com/api/applications/#api-Rules-ListRules
     */
    getAllRules(accountId: string, queryParams?: AlApplicationConfigQuery, deploymentId?: string): Promise<AlRule[]>;
    /**
     * Allows to delete a rule
     * DELETE
     * /applications/v1/:account_id/rules/:rule_id
     *
     * @param accountId The AIMS Account ID
     * @param ruleId The Rule identifier to delete
     * @returns just the status code
     *
     * @remarks
     * https://api.product.dev.alertlogic.com/applications/v1/01000001/rules/B37CEE84-6D27-4D0F-943C-F23937587574
     */
    deleteRule(accountId: string, ruleId: string): Promise<any>;
    /**
     * Update a Rule
     * PUT
     * /applications/v1/:account_id/rules/:rule_id
     *
     * @param notificationType The notification type as string
     * @param payload Notification type object
     * @param deploymentId deployment id (optional)
     * @returns a promise with the notification type that was updated
     *
     * @remarks
     * https://api.product.dev.alertlogic.com/applications/v1/01000001/rules/BD30F3F3-5D12-421A-B806-C65155C40CE1
     */
    updateRule(accountId: string, ruleId: string, payload: AlRulePayload, deploymentId?: string): Promise<AlRule>;
    /**
     * Return the list of log collection rules for a deployment
     * GET
     * /applications/v1/:account_id/deployments/:deployment_id/rules
     * "https://api.product.dev.alertlogic.com/applications/v1/01000001/deployments/E78E4878-A96E-48BD-A27B-0EE56BEA1FE4/rules"
     *
     *  @param accountId AIMS Account ID
     *  @returns a promise with the rules list of a given deployment
     *
     *  @remarks
     *  https://console.product.dev.alertlogic.com/api/applications/#api-Rules-ListRulesDepl
     */
    getAllRulesByDeployment(accountId: string, deploymentId: string): Promise<AlRuleForDeployment[]>;
    /**
     * Deploys a collector with given parameters
     * POST
     * /applications/v1/:account_id/collectors
     * curl -X POST https://api.product.dev.alertlogic.com/applications/v1/01000001/collectors -d
     * {
     *      "name": "okta",
     *      "application_id": "16",
     *      "parameters": {
     *          "domain_url": "https://alertlogic.okta.com/",
     *          "api_key": "api_key_123456",
     *          "collection_start_ts": "56726151727"
     *      }
     * }
     *
     * @param accountId AIMS Account ID
     * @param data The collector request body
     * @returns a promise with the subscriptions
     *
     * @remarks
     * https://console.product.dev.alertlogic.com/api/applications/index.html#api-Collectors-DeployCollector
     */
    deployACollector(accountId: string, data: AlDeployACollectorPayload): Promise<AlDeployACollector>;
    /**
     * Deletes deployed collector by id
     * DELETE
     * /applications/v1/:account_id/collectors/:collector_id
     *
     * @param accountId The AIMS Account ID
     * @param collectorId A v4 UUID generated when collector is deployed
     * @returns just the status code
     *
     * @remarks
     * https://api.product.dev.alertlogic.com/applications/v1/01000001/rules/B37CEE84-6D27-4D0F-943C-F23937587574
     */
    deleteADeployedCollector(accountId: string, collectorId: string): Promise<any>;
    /**
     * Updates an already deployed collector with given parameters
     * PUT
     * /applications/v1/:account_id/collectors/:collector_id
     *
     * @param accountId The AIMS Account ID
     * @param collectorId A v4 UUID generated when collector is deployed
     *
     * @remarks
     * https://console.product.dev.alertlogic.com/api/applications/index.html#api-Collectors-UpdateDeployedCollector
     */
    updateADeployedCollector(accountId: string, collectorId: string, data: AlDeployACollectorPayload): Promise<DeployedCollectorUpdateResponse>;
    /**
     * Return the attributes list
     * GET
     * /applications/v1/:account_id/attributes
     * "https://api.product.dev.alertlogic.com/applications/v1/01000001/attributes"
     *
     *  @param accountId AIMS Account ID
     *  @returns a promise with the attributes list
     *
     *  @remarks
     *  https://console.product.dev.alertlogic.com/api/applications
     */
    getAllAttributes(accountId: string): Promise<Array<AlApplicationAttribute>>;
}

export declare interface AlApplicationScope {
    type?: string;
    pattern?: string;
}

export declare interface AlApplicationStream {
    name: string;
}

export declare interface AlApplicationSyslog {
    container_logs_enabled?: boolean;
    disk_cache_size?: number;
    disk_limit?: number;
    agent_port?: number;
    use_original_ts?: boolean;
}

export declare interface AlAssetScanCredentials {
    name?: string;
    type?: 'ssh' | 'windows' | 'snmp_community_string';
    sub_type?: 'user' | 'key';
    username?: string;
    password?: string;
    key?: string;
    snmp_community_string?: string;
}

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

/**
 * Describes who and when modified the parent object.
 */
export declare interface AlAuditObject {
    at?: Date;
    by?: string;
}

declare interface AlBaseApplication {
    id: string;
    name: string;
    type?: string;
    created: AlChangeStamp;
    modified: AlChangeStamp;
    config?: AlApplicationConfig;
    attributes?: string[];
}

export { AlChangeStamp }

export declare interface AlConfig {
    qfields: {
        type: string;
        tags: {
            [key: string]: string;
        };
        protection_policy_name?: string;
        name?: string;
        key: string;
        alertlogic_appliance?: string;
        deployment_id: string;
        vpc?: AlConfigAssetType;
        subnet?: AlConfigAssetType;
        region?: AlConfigAssetType;
        deployment?: AlConfigDeployment;
    };
    policy_ids: string[];
    features_config: {};
    feature_types: string[];
    deployment_id: string;
    asset_type: string;
    asset_key: string;
    account_id: string;
}

export declare interface AlConfigAssetType {
    type: string;
    tags: {
        [key: string]: string;
    };
    protection_policy_name?: string;
    name?: string;
    key: string;
    deployment_id: string;
    alertlogic_appliance?: string;
}

export declare class AlConfigClientV2 {
    client: AlApiClient;
    protected serviceVersion: string;
    protected serviceName: string;
    constructor(client?: AlApiClient);
    /**
     * Returns a list of configurations for assets of a given type that match given filters
     * @param accountId
     * @param qParams
     * @returns list of configurations
     * https://console.account.alertlogic.com/users/api/config/#api-Configuration-GetAssetConfigs
     */
    listConfigs(accountId: string, qParams: {
        [key: string]: string | Object;
    }): Promise<AlConfig[]>;
}

export declare interface AlConfigDeployment {
    version: number;
    status: {
        updated: number;
        status: string;
    };
    scope: AlConfigDeploymentScope;
    scan: boolean;
    platform: AlConfigPlatform;
    name: string;
    modified: {
        by: string;
        at: number;
    };
    mode: string;
    id: string;
    features: {
        abs: {
            scope: AlConfigScope[];
        }[];
    };
    enabled: true;
    discover: true;
    credentials: {
        version: string;
        purpose: string;
        id: string;
    }[];
    created: {
        by: string;
        at: number;
    };
    cloud_defender: {
        location_id: string;
        enabled: boolean;
    };
    account_id: string;
}

export declare interface AlConfigDeploymentScope {
    include: AlConfigScope[];
    exclude: AlConfigScope[];
}

export declare interface AlConfigPlatform {
    type: string;
    monitor?: {
        enabled: boolean;
        ct_install_region: string;
        id: string;
    };
}

export declare type AlConfigScope = {
    type: string;
    policy?: {
        id: string;
    };
    key: string;
};

export declare const ALConfigV2: AlConfigClientV2;

export declare interface AlControlApplication {
    updateNotAllowed: boolean;
    type: string;
    property: string;
    label: string;
    description: string;
    defaultValue?: string | string[] | boolean;
    validationPattern?: string;
    optional?: boolean;
    options?: AlOptionFormApplication[];
}

export declare interface AlCredential {
    id?: string;
    modified?: AlChangeStamp;
    name?: string;
    secrets?: AlCredentialSecrets;
    created?: AlChangeStamp;
}

export declare const AlCredentialsClient: AlCredentialsClientInstance;

export declare class AlCredentialsClientInstance {
    protected serviceVersion: string;
    private serviceName;
    constructor();
    /**
     * Delete scan credentials for an asset
     * DELETE
     * /credentials/v1/:account_id/:environment_id/:asset_type/scan/:credential_type/:asset_key
     * "https://api.cloudinsight.alertlogic.com/credentials/v1/01000001/5955C10B-33A2-41A0-9E73-10CBD51FA9CF/host/scan/ssh/aws/us-west-2/host/i-4e751943"
     */
    deleteHostScanCredentials(accountId: string, environmentId: string, assetType: string, credentialType: string, assetKey: string): Promise<void>;
    /**
     * @deprecatd use getScanCredentials instead
     * Get scan credentials for a host
     * GET
     * /credentials/v1/:account_id/:environment_id/host/scan/:asset_key
     * "https://api.cloudinsight.alertlogic.com/credentials/v1/01000001/5955C10B-33A2-41A0-9E73-10CBD51FA9CF/host/scan/aws/us-west-2/host/i-4e751943"
     */
    getHostScanCredentials(accountId: string, environmentId: string, assetKey: string): Promise<AlScanCredentialsResponse>;
    /**
     * Get scan credentials for an asset
     * GET
     * /credentials/v1/:account_id/:environment_id/:asset_type/scan/:asset_key
     * "https://api.product.dev.alertlogic.com/credentials/v1/134249236/0C51E404-4BB4-4228-B6B7-32B43029C76F/vpc/scan/dc/network/D4BC698D-54E1-4422-9F0B-9F21B064A9E4"
     */
    getScanCredentials(accountId: string, deploymentId: string, assetType: string, assetKey: string): Promise<AlScanCredentialsResponse>;
    /**
     * Get scan credentials for all hosts
     * GET
     * /credentials/v1/:account_id/:environment_id/host/scan
     * "https://api.cloudinsight.alertlogic.com/credentials/v1/01000001/5955C10B-33A2-41A0-9E73-10CBD51FA9CF/host/scan"
     */
    getAllHostScanCredentials(accountId: string, environmentId: string): Promise<AlScanCredentialsAllHosts>;
    /**
     * Store scan credentials for an asset
     * PUT
     * /credentials/v1/:account_id/:environment_id/:asset_type/scan/:asset_key
     * "https://api.cloudinsight.alertlogic.com/credentials/v1/01000001/5955C10B-33A2-41A0-9E73-10CBD51FA9CF/host/scan/aws/us-west-2/host/i-4e751943"
     * -d '{"name": "Cred", "type": "ssh", "sub_type": "key", "username": "", "key": "PRIVATE KEY"}'
     */
    storeHostScanCredential(accountId: string, environmentId: string, assetType: string, assetKey: string, credential: AlAssetScanCredentials): Promise<AlCredentialsStoredResponse>;
    getAssetsCredentialsByType(accountId: string, deploymentId: string, type: string, assetId: string): Promise<AlScanCredentialsResponse>;
}

export declare const AlCredentialsClientV2: AlCredentialslientV2Instance;

export declare interface AlCredentialSecrets {
    type?: 'aws_iam_role' | 'azure_ad_user' | 'azure_ad_client' | 'keypair';
    arn?: string;
    external_id?: string;
    ad_id?: string;
    username?: string;
    client_id?: string;
    client_secret?: string;
    certificate?: string;
    private_key?: string;
}

export declare class AlCredentialslientV2Instance {
    client: AlApiClient;
    protected serviceVersion: string;
    private serviceName;
    constructor(client?: AlApiClient);
    /**
     * Create Credential
     * POST
     * /credentials/v2/:account_id/credentials
     * "https://api.cloudinsight.alertlogic.com/credentials/v1/01000001/credentials"
     * -d '{"name":"IAM Role","secrets":{"type":"aws_iam_role","arn":"ARN"}}'
     */
    create(accountId: string, credential: AlCredential): Promise<AlCredential>;
    /**
     * Delete Credential
     * DELETE
     * /credentials/v2/:account_id/credentials/:credential_id
     * "https://api.cloudinsight.alertlogic.com/credentials/v1/01000001/credentials/5955C10B-33A2-41A0-9E73-10CBD51FA9CF"
     */
    delete(accountId: string, credentialId: string): Promise<void>;
    /**
     * Get credential
     * GET
     * /credentials/v2/:account_id/credentials/:credential_id
     * "https://api.cloudinsight.alertlogic.com/credentials/v2/01000001/credentials/BD7592C5-0111-1005-83EE-7831C1BAEAE6"
     */
    getById(accountId: string, credentialId: string): Promise<AlCredential>;
    /**
     * List credentials
     * GET
     * /credentials/v2/:account_id/credentials
     * "https://api.cloudinsight.alertlogic.com/credentials/v2/01000001/credentials"
     */
    listAll(accountId: string): Promise<AlCredential[]>;
}

export declare type AlCredentialsStoredResponse = {
    credential_id: string;
};

export declare interface AlDecryptedCredential {
    id: string;
    type: string;
    arn?: string;
    external_id?: string;
    subscription_id?: string;
    ad_id?: string;
    client_id?: string;
    username?: string;
    password?: string;
    client_secret?: string;
    keypair_type?: string;
    certificate?: string;
    private_key?: string;
}

export declare interface AlDeployACollector {
    collector_id: string;
}

export declare interface AlDeployACollectorPayload {
    name: string;
    application_id: string;
    parameters: any;
}

export declare const AlExclusionsClient: AlExclusionsClientInstance;

export declare class AlExclusionsClientInstance {
    protected serviceName: string;
    protected serviceVersion: string;
    constructor();
    /**
     * @remarks https://console.cloudinsight.alertlogic.com/api/exclusions/index.html#api-Exclusion_Rules-GetRules
     */
    listRules(accountId: string, deploymentId: string, searchParams?: {
        [i: string]: string;
    }): Promise<ExclusionsRulesSnapshot>;
    /**
     * @remarks https://console.cloudinsight.alertlogic.com/api/exclusions/index.html#api-Exclusion_Rules-GetRule
     */
    getRule(accountId: string, deploymentId: string, ruleId: string): Promise<ExclusionsRulesDescriptor>;
    /**
     * @remarks https://console.cloudinsight.alertlogic.com/api/exclusions/index.html#api-Exclusion_Rules-DeleteExclusionRule
     */
    deleteRule(accountId: string, deploymentId: string, ruleId: string): Promise<void>;
    /**
     * @remarks https://console.cloudinsight.alertlogic.com/api/exclusions/index.html#api-Exclusion_Rules-CreateExclusionRule
     */
    createRule(accountId: string, deploymentId: string, data: ExclusionsRulesDescriptor): Promise<ExclusionsRulesDescriptor>;
    /**
     * @remarks https://console.cloudinsight.alertlogic.com/api/exclusions/index.html#api-Exclusion_Rules-UpdateExclusionRule
     */
    updateRule(accountId: string, deploymentId: string, ruleId: string, data: ExclusionsRulesDescriptor): Promise<ExclusionsRulesDescriptor>;
    /**
     * @remarks https://console.product.dev.alertlogic.com/api/exclusions/#api-Is_Asset_Excluded_API-ApplyExclusionRule
     */
    isExcluded(accountId: string, deploymentId: string, assetType: string, assetKey: string, feature?: string, searchParams?: {
        [i: string]: string;
    }): Promise<ExclusionsRulesDescriptor>;
}

export declare interface AlFimAsset {
    type: fimAssetType;
    key?: string;
    name?: string;
    value?: string;
}

declare interface AlFimChangeStamp extends AlChangeStamp {
    at_iso: string;
}

export declare const AlFimClient: AlFimClientInstance;

export declare class AlFimClientInstance {
    protected serviceName: string;
    protected serviceVersion: string;
    constructor();
    /**
     * Lists all fim excluded or monitored path configuration objects
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-MonitoredPaths-ListConfigurations
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-ExcludedPaths-ListConfigurations
     */
    getAllConfigurations(pathType: fimPathType, accountId: string, deploymentId: string): Promise<AlFimConfiguration[]>;
    /**
     *  Gets a single fim excluded or monitored path configuration object
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-MonitoredPaths-GetConfiguration
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-ExcludedPaths-GetConfiguration
     */
    getConfiguration(pathType: fimPathType, accountId: string, deploymentId: string, configurationId: string): Promise<AlFimConfiguration>;
    /**
     *  creates a fim excluded or monitored path configuration object
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-MonitoredPaths-CreateConfiguration
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-ExcludedPaths-CreateConfiguration
     */
    createConfiguration(pathType: fimPathType, accountId: string, deploymentId: string, payload: AlFimConfiguration): Promise<AlFimConfiguration>;
    /**
     *  updates a fim excluded or monitored path configuration object
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-MonitoredPaths-UpdateConfiguration
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-ExcludedPaths-CreateConfiguration
     */
    updateConfiguration(pathType: fimPathType, accountId: string, deploymentId: string, configurationId: string, payload: AlFimConfiguration): Promise<AlFimConfiguration>;
    /**
     *  Deletes a fim excluded or monitored path configuration object
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-MonitoredPaths-DeleteConfiguration
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-ExcludedPaths-DeleteConfiguration
     */
    deleteConfiguration(pathType: fimPathType, accountId: string, deploymentId: string, configurationId: string): Promise<void>;
    /**
     *  Gets the configuration summary report
     *  @remarks
     *  https://console.account.product.dev.alertlogic.com/users/api/fim_config/index.html#api-Reports-GetSummary
     */
    getConfigurationsSummary(accountId: string): Promise<AlFimConfigurationSummaryReport>;
}

export declare interface AlFimConfiguration {
    id: string;
    type: fimConfigType;
    base: string;
    pattern?: string;
    description?: string;
    enabled?: boolean;
    version?: number;
    recursive?: boolean;
    operations?: fimMonitoredOperation[];
    scope?: AlFimAsset[];
    created?: AlFimChangeStamp;
    modified?: AlFimChangeStamp;
    system?: boolean;
}

export declare interface AlFimConfigurationReportTypes {
    win_reg: AlFimCountReport;
    win_dir: AlFimCountReport;
    nix_dir: AlFimCountReport;
}

export declare interface AlFimConfigurationSummaryReport {
    monitored_paths: AlFimConfigurationReportTypes;
    excluded_paths: AlFimConfigurationReportTypes;
}

export declare interface AlFimCountReport {
    total_num: number;
    num_enabled: number;
}

export declare interface AlFormApplication {
    controls: AlControlApplication[];
}

/**
 * Provides the results of IP Address Validation function.
 */
export declare interface AlIPValidationResult {
    /**
     * List of valid IP Addresses that can be used as ScanScopeItems.
     */
    valid?: (AlScanScopeItemCIDR | AlScanScopeItemIPRange | AlScanScopeItemIPAddress)[];
    /**
     * List of strings that are invalid and/or don't match any of supported formats of ScanScopeItems.
     * Will be returned literally as they were entered.
     */
    invalid?: string[];
    /**
     * List of valid IP Addresses that can optionally be used as ScanScopeItems, but they are outside of deployment's scope of protection.
     * Scan targets with IP addresses that match `out_of_scope` items will not be scanned unless the scope of protection have been changed to include them.
     */
    out_of_scope?: (AlScanScopeItemCIDR | AlScanScopeItemIPRange | AlScanScopeItemIPAddress)[];
}

export declare class AllExclusionsToSave {
    external_scanning: Array<ExclusionsAssets>;
    internal_scanning: Array<ExclusionsAssets>;
    agent_scanning: Array<ExclusionsAssets>;
    internal_scanning_ports: {
        asset: ExclusionsAssets;
        details: ExlusionsDetails[];
        ruleId: string;
    }[];
    external_scanning_ports: {
        asset: ExclusionsAssets;
        details: ExlusionsDetails[];
        ruleId: string;
    }[];
    networks_ids: Array<CidrType>;
    networks_deleted: Array<string>;
    ports_rules_deleted: Array<string>;
    changes: boolean;
}

export declare interface AlOptionFormApplication {
    label: string;
    value: string;
}

export declare const AlPoliciesClient: AlPoliciesClientInstance;

export declare class AlPoliciesClientInstance {
    protected serviceVersion: string;
    private serviceName;
    constructor();
    /**
     * Returns the policy matching account_id and policy_id specified
     */
    getPolicy(accountId: string, policyId: string): Promise<Policy>;
    /**
     * Lists policies belonging to a particular account
     */
    listPolicies(accountId: string): Promise<Policy[]>;
}

export declare interface AlRule extends AlBaseApplication {
    scope: (AlAssetScopeItem | AlTagScopeItem)[];
    version: number;
    application_id: string;
    account_id: string;
    enabled?: boolean;
    default?: boolean;
    parameters?: {
        [i: string]: any;
    };
    search_by?: {
        [i: string]: any;
    }[];
}

export declare interface AlRuleForDeployment extends AlRule {
    deployment_id: string;
}

export declare interface AlRulePayload {
    name?: string;
    deployment_id?: string;
    application_id?: string;
    path?: string;
    config?: AlApplicationConfig;
    scope?: (AlAssetScopeItem | AlTagScopeItem)[];
    enabled?: boolean;
    default?: boolean;
    parameters?: {
        [i: string]: any;
    };
}

export declare interface AlScanCredential {
    id?: string;
    modified?: AlChangeStamp;
    name?: string;
    product_type?: string;
    type?: string;
    created: AlChangeStamp;
    windows?: AlScanCredentialType;
    ssh?: AlScanCredentialType;
}

export declare interface AlScanCredentialsAllHosts {
    hosts: {
        [key: string]: {
            ssh?: string;
            windows?: string;
        };
    };
}

export declare interface AlScanCredentialsResponse {
    credentials: AlScanCredential[];
}

export declare interface AlScanCredentialType {
    username?: string;
    password?: string;
    ssh_type?: string;
    key?: string;
}

/**
 * Scan Schedule definition.
 */
export declare interface AlScanSchedule {
    readonly id?: string;
    name?: string;
    /**
     * Each new deployment will have a default scan schedule created for each type of scan, where applicable.
     * The parameter specifies whether the schedule is default or not.
     * A default schedule:
     *  - includes all targets in the scope
     *  - can't be deleted
     *  - can be disabled (except from `discovery` type of scan)
     *  - can be modified as far as scan scope, scan windows and frequencies are concerned
     *  - note a default schedule for the `discovery` scan type always includes all the assets in its scope
     */
    readonly default?: boolean;
    /**
     * Specifies whether the schedule is active or not.
     */
    enabled?: boolean;
    /**
     * Specifies which type of scan the schedule should apply to. There are 3 types of scans
     *   vulnerability - internal network scan. Requires an appliance to be deployed within a customer's network.
     *                   Primary target are assets of host type that are in the scope of the schedule and within
     *                   the scope of protection of the deployment.
     *   external - external network scan. Does not require appliances to be deployed, as it is performed from within
     *              Alert Logic network against external assets. Primary target are assets of external-ip and external-dns-name
     *              types that are in the scope of the schedule and within the scope of protection of the deployment.
     *   discovery - internal host-lookup scan. Requires an appliance to be deployed within a customer's network.
     *               Specific only to datacenter type of deployment, where cloud API cannot be used to enumerate assets.
     *               Used primarily to find active hosts in networks that are in the scope of protection of the deployment.
     *               Primary target are assets of network or vpc type.
     */
    type_of_scan?: AlScanSchedule.TypeOfScanEnum;
    /**
     * Name of the timezone that should be used for the ScanSchedule object.
     * The list of all supported timezones can be obtained with `/scheduler/v2/timezones` API.
     * Accepted values are derived from `Timezone.tz_name` field.
     * Please note Daylight Saving Time will be observed and applied automatically, depending on a specified value.
     * This field is optional with `null` value defaulting to `UTC` time zone.
     */
    timezone?: string;
    /**
     * Specifies the SLA period of how frequently consecutive scans should target individual targets within the deployment.
     * Depending on characteristicts of the workload or its compliance and security requirements,
     * different targets (e.g. hosts, external ip addresses, networks) of a certain scanning scope
     * (e.g. hosts within certain subnets or belonging to certain CIDR ranges) may require different frequency of scans.
     * By setting `scan_frequency` to `weekly`, Alert Logic will aim to scan each target within the scope of a Scan Schedule
     * once every 7 days (168 hours), adhering to the date/time constraints specified by `scan_windows` parameter.
     * Please note when the same host effectively belongs to two distinct Scan Schedules, the higher frequency
     * (e.g. daily over weekly) will be respected for both schedules and union of `scan_windows` will be considered
     * as time periods when scans will be allowed to occur.
     */
    scan_frequency?: AlScanSchedule.ScanFrequencyEnum;
    /**
     * Specifies the time periods when the Scan Schedule should be active.
     * Please note there are four types of `scan_windows`, defined as following models:
     * - `ScanWindowSelectedDaysOfWeek`
     * - `ScanWindowSelectedDaysOfMonth`
     * - `ScanWindowContinuousPeriodWeekly`
     * - `ScanWindowContinuousPeriodMonthly`
     * - `ScanWindowSpecificDate`
     * - `ScanWindowContinuousQuarterly`
     * - `ScanWindowSelectedWeekdayOfMonth'
     * For details please refer to the documentation of the above models.
     */
    scan_windows?: (AlScanWindowSelectedDaysOfWeek | AlScanWindowSelectedDaysOfMonth | AlScanWindowContinuousPeriodWeekly | AlScanWindowContinuousPeriodMonthly | AlScanWindowSpecificDate | AlScanWindowContinuousQuarterly | AlScanWindowSelectedWeekdayOfMonth)[];
    /**
     * Specifies what assets are considered to be scanned within designated periods defined by `scan_windows` parameter,
     * setting the SLA as specified by `scan_frequency` parameter.
     */
    scan_scope?: AlScanScope;
    /**
     * An optional list of Scan Options, that affect the scan configuration. One of the supported options is a list of ports
     */
    scan_options?: ScanOptionPorts[];
    created?: AlAuditObject;
    modified?: AlAuditObject;
}

export declare namespace AlScanSchedule {
    export type TypeOfScanEnum = 'vulnerability' | 'external' | 'discovery' | 'abs';
    const typeOfScanEnum: {
        Vulnerability: TypeOfScanEnum;
        External: TypeOfScanEnum;
        Discovery: TypeOfScanEnum;
        Abs: TypeOfScanEnum;
    };
    export type ScanFrequencyEnum = 'automatic' | 'daily' | 'weekly' | 'fortnightly' | 'monthly' | 'quarterly' | 'once';
    const scanFrequencyEnum: {
        Automatic: ScanFrequencyEnum;
        Daily: ScanFrequencyEnum;
        Weekly: ScanFrequencyEnum;
        Fortnightly: ScanFrequencyEnum;
        Monthly: ScanFrequencyEnum;
        Quarterly: ScanFrequencyEnum;
        Once: ScanFrequencyEnum;
    };
}

export declare class AlScanSchedulerClientInstanceV2 {
    private serviceName;
    /**
     *  Lists scan schedules that belong to a particular deployment
     */
    getScanSchedulesList(accountId: string, deploymentId: string, params?: QParams): Promise<AlScanSchedule[]>;
    /**
     *  Create new Scan Schedule for a given deployment
     */
    createScanSchedule(accountId: string, deploymentId: string, schedule: AlScanSchedule): Promise<AlScanSchedule>;
    /**
     *  Returns the scan schedule definition for a given id
     */
    getScanSchedule(accountId: string, deploymentId: string, scheduleId: string): Promise<AlScanSchedule>;
    /**
     *  Deletes Selected Schedule
     */
    removeScanSchedule(accountId: string, deploymentId: string, scheduleId: string): Promise<void>;
    /**
     *   Updates a selected scan schedule
     */
    updateScanSchedule(accountId: string, deploymentId: string, scheduleId: string, schedule: AlScanSchedule): Promise<AlScanSchedule>;
    /**
     *  Get scan schedule summary by ID
     */
    getScanScheduleSummary(accountId: string, deploymentId: string, scheduleId: string, params?: QParams): Promise<AlScanScheduleSummary>;
    /**
     *  Validates a list of supplied IP Addresses, checking for their correctness.
     *  This API always returns 200 OK status and provides the results of validation using two arrays with respective status (valid/invalid).
     *  IP Addresses that are present in the valid list can be subsequently used as applicable ScanScopeItems.
     */
    validateIp(accountId: string, deploymentId: string, ips: string[], typeOfScan?: AlScanSchedule.TypeOfScanEnum): Promise<AlIPValidationResult>;
    /**
     *  Lists supported timezones that can be used in ScanWindow definition
     */
    getTimeZonesList(): Promise<AlTimeZone[]>;
    /**
     *  Expedites scan for all the scannable targets that are descendants of a given
     *  level of the topology (for example all hosts belonging to a given subnet)
     *
     *  @force param: Allows to override the exclusion rules applied to selected targets.
     *                Otherwise exclusion rules take precedence over expedited scan.
     */
    scanNow(accountId: string, deploymentId: string, scanScopeItem: AlScanScopeItemAsset, params?: {
        force: boolean;
    }): Promise<void>;
    /**
     * Stops scans for selected list of assets
     * All scan jobs currently running against targets that are within the scope defined by the ScanScopeItem object, will be terminated.
     * Targets will not be re-enqueued until the next scan SLA period defined by scan_frequency parameter of a schedule that contains each of the targets.
     * @param accountId
     * @param deploymentId
     */
    stopScanAssets(accountId: string, deploymentId: string, scanScopeItem: AlScanScopeItemAsset): Promise<void>;
    /**
     * Stops a selected scan schedule
     * All scan jobs currently running against targets that are within the scope defined by the selected schedule, will be terminated.
     * Targets will not be re-enqueued until the next scan SLA period defined by scan_frequency parameter of the schedule.
     * @param accountId
     * @param deploymentId
     * @param scanScheduleId
     */
    stopScanSchedule(accountId: string, deploymentId: string, scanScheduleId: string): Promise<void>;
}

export declare const AlScanSchedulerClientV2: AlScanSchedulerClientInstanceV2;

/**
 * Provides a summary of outcomes for a given schedule `id`. For instance what is the scope of the schedule, its status, and SLA.
 */
export declare interface AlScanScheduleSummary {
    /**
     * The total number of scannable assets that are in the scope of a given schedule.
     */
    assets_number?: number;
    /**
     * Number of assets that have met the SLA specified by `scan_frequency` parameter.
     */
    assets_in_sla?: number;
    /**
     * Number of assets that are excluded and are not counted into the SLA specified by `scan_frequency` parameter.
     */
    assets_excluded?: number;
    /**
     * Number of assets that are due to be scanned within the scope of the schedule to meet its SLA.
     */
    assets_to_scan?: number;
    /**
     * Timestamp of the last successful scan executed within the scope of  the schedule.
     */
    last_scan_date?: Date;
    /**
     * Timestamp describing the next planned scan execution within the scope of  the schedule.
     */
    next_scan_date?: Date;
    status?: AlScanScheduleSummary.StatusEnum;
}

export declare namespace AlScanScheduleSummary {
    export type StatusEnum = 'disabled' | 'idle' | 'in_progress' | 'stopped';
    const statusEnum: {
        Disabled: StatusEnum;
        Idle: StatusEnum;
        InProgress: StatusEnum;
        Stopped: StatusEnum;
    };
}

/**
 * Specifies what assets are considered to be scanned within designated periods defined by
 * `scan_windows` parameter, setting the SLA as specified by `scan_frequency` parameter.
 */
export declare interface AlScanScope {
    /**
     * When set to `true` all assets in the scope of deployment's protection are included within the schedule.
     * Values specified in `include` array will not be taken into account.
     */
    include_all_assets?: boolean;
    include?: (AlScanScopeItemAsset | AlScanScopeItemCIDR | AlScanScopeItemIPRange | AlScanScopeItemTag | AlScanScopeItemIPAddress)[];
}

/**
 * Element of `scan_scope` list that specifies which assets should be taken into account
 * when a given scan schedule is concerned. Please note that `ScanAsset` might be either a
 * concrete asset i.e. `deployment`, `network`, `subnet`, `host`, or can be an abstract asset
 * qualificator such as `IP` range, `CIDR` range or a `tag`.
 */
export declare interface AlScanScopeItem {
    type?: AlScanScopeItem.TypeEnum;
}

export declare namespace AlScanScopeItem {
    export type TypeEnum = 'asset' | 'cidr' | 'ip_address' | 'ip_range' | 'tag';
    const typeEnum: {
        Asset: TypeEnum;
        Cidr: TypeEnum;
        IpAddress: TypeEnum;
        IpRange: TypeEnum;
        Tag: TypeEnum;
    };
}

export declare interface AlScanScopeItemAsset extends AlScanScopeItem {
    /**
     * Specifies the type of the asset added to the scan scope.
     * Following asset types are supported:
     * - `deployment`
     * - `region`
     * - `network`
     * - `vpc` (alias of the `network` type)
     * - `subnet`
     * - `host`
     * - `external-ip`
     * - `external-dns-name`
     */
    asset_type?: AlScanScopeItemAsset.AssetTypeEnum;
    key: string;
    type: AlScanScopeItemAsset.TypeEnum;
}

export declare namespace AlScanScopeItemAsset {
    export type AssetTypeEnum = 'deployment' | 'region' | 'network' | 'vpc' | 'subnet' | 'host' | 'external-ip' | 'external-dns-name';
    const assetTypeEnum: {
        Deployment: AssetTypeEnum;
        Region: AssetTypeEnum;
        Network: AssetTypeEnum;
        Vpc: AssetTypeEnum;
        Subnet: AssetTypeEnum;
        Host: AssetTypeEnum;
        ExternalIp: AssetTypeEnum;
        ExternalDnsName: AssetTypeEnum;
    };
    export type TypeEnum = 'asset';
    const typeEnum: {
        Asset: "asset";
    };
}

export declare interface AlScanScopeItemCIDR extends AlScanScopeItem {
    value: string;
    type?: AlScanScopeItemCIDR.TypeEnum;
}

export declare namespace AlScanScopeItemCIDR {
    export type TypeEnum = 'cidr';
    const typeEnum: {
        Cidr: "cidr";
    };
}

export declare interface AlScanScopeItemIPAddress extends AlScanScopeItem {
    value: string;
    type?: AlScanScopeItemIPAddress.TypeEnum;
}

export declare namespace AlScanScopeItemIPAddress {
    export type TypeEnum = 'ip_address';
    const typeEnum: {
        Address: "ip_address";
    };
}

export declare interface AlScanScopeItemIPRange extends AlScanScopeItem {
    from_ip: string;
    to_ip: string;
    type?: AlScanScopeItemIPRange.TypeEnum;
}

export declare namespace AlScanScopeItemIPRange {
    export type TypeEnum = 'ip_range';
    const typeEnum: {
        Range: "ip_range";
    };
}

export declare interface AlScanScopeItemTag extends AlScanScopeItem {
    key?: string;
    value?: string;
    type?: AlScanScopeItemTag.TypeEnum;
}

export declare namespace AlScanScopeItemTag {
    export type TypeEnum = 'tag';
    const typeEnum: {
        Tag: "tag";
    };
}

/**
 * Scan Window specifies when assets within a scope of a schedule should be scanned,
 * adhering to the `scan_frequency` parameter. Depending on the `type_of_window`
 * parameter different time windows can be specified.
 */
export declare interface AlScanWindow {
    type?: AlScanWindow.TypeEnum;
}

export declare namespace AlScanWindow {
    export type TypeEnum = 'days_of_week' | 'days_of_month' | 'weekly_period' | 'monthly_period' | 'specific_date' | 'quarterly' | 'weekday_of_month';
    const typeEnum: {
        DaysOfWeek: TypeEnum;
        DaysOfMonth: TypeEnum;
        WeeklyPeriod: TypeEnum;
        MonthlyPeriod: TypeEnum;
        SpecificDate: TypeEnum;
        Quarterly: TypeEnum;
        WeekdayOfMonth: TypeEnum;
    };
}

/**
 * Scan window for continuous period between two days of month, with start time/day and end time/day.
 */
export declare interface AlScanWindowContinuousPeriodMonthly extends AlScanWindow {
    type: AlScanWindowContinuousPeriodMonthly.TypeEnum;
    /**
     * Day of month when continuous scanning window commences (`1 - 31`).
     * If selected day is not applicable to the month, the nearest date will be used instead.
     * E.g. a scan set to run on the \"30th\" will run February 28th. For API consumer's convenience `31`
     * will ALWAYS be considered as the  END_OF_MONTH wildcard.
     */
    start_day: number;
    /**
     * Time of day when continuous scanning window commences (24h format)
     */
    start_time: string;
    /**
     * Day of month when continuous scanning window ends (`1 - 31`)
     * If selected day is not applicable to the month, the nearest date will be used instead.
     * E.g. a scan set to run on the \"30th\" will run February 28th. For API consumer's convenience `31`
     * will ALWAYS be considered as the  END_OF_MONTH wildcard.
     */
    end_day: number;
    /**
     * Time of day when continuous scanning window ends (24h)
     */
    end_time: string;
}

export declare namespace AlScanWindowContinuousPeriodMonthly {
    export type TypeEnum = 'monthly_period';
    const typeEnum: {
        Period: "monthly_period";
    };
}

/**
 * Scan window for continuous period between two days of week.
 * Effectively the window will allow scans to occur continuously
 * between `start_day`/`start_time` and `end_day`/`end_time`.
 */
export declare interface AlScanWindowContinuousPeriodWeekly extends AlScanWindow {
    type: AlScanWindowContinuousPeriodWeekly.TypeEnum;
    /**
     * Day of week when continuous scanning window commences (`1 - 7`, where `1` is Monday and `7` is Sunday)
     */
    start_day: number;
    /**
     * Time of day when continuous scanning window commences (24h format)
     */
    start_time: string;
    /**
     * Day of week when continuous scanning window ends (`1 - 7`, where `1` is Monday and `7` is Sunday)
     */
    end_day: number;
    /**
     * Time of day when continuous scanning window ends (24h format)
     */
    end_time: string;
}

export declare namespace AlScanWindowContinuousPeriodWeekly {
    export type TypeEnum = 'weekly_period';
    const typeEnum: {
        Period: "weekly_period";
    };
}

export declare interface AlScanWindowContinuousQuarterly extends AlScanWindow {
    type: AlScanWindowContinuousQuarterly.TypeEnum;
    /**
     * Day of month when continuous scanning window commences (`1 - 31`).
     * If selected day is not applicable to the month, the nearest date will be used instead.
     * E.g. a scan set to run on the \"30th\" will run February 28th. For API consumer's convenience `31`
     * will ALWAYS be considered as the END_OF_MONTH wildcard.
     */
    start_day: number;
    /**
     * Time of day when specific date scanning window commences (24h format, `HH:MM`)
     */
    start_time: string;
    /**
     * Day of month when continuous scanning window ends (`1 - 31`) If selected day is not applicable to the month,
     * the nearest date will be used instead. E.g. a scan set to run on the \"30th\" will run February 28th.
     * For API consumer's convenience `31` will ALWAYS be considered as the END_OF_MONTH wildcard.
     */
    end_day: number;
    /**
     * Time of day when continuous scanning window ends (24h format, `HH:MM`)
     */
    end_time: string;
    /**
     * Month of the quarter when the scan should take place; The 1st, 2nd or 3rd month of each quarter.
     */
    month_of_quarter: number;
}

export declare namespace AlScanWindowContinuousQuarterly {
    export type TypeEnum = 'quarterly';
    const typeEnum: {
        Quarterly: "quarterly";
    };
}

/**
 * Scan window for selected days of month, with daily start and end times.
 * Effectively the window will be active every day according to `days_of_month` list,
 * between specified times `start_time` and `end_time`.
 */
export declare interface AlScanWindowSelectedDaysOfMonth extends AlScanWindow {
    type: AlScanWindowSelectedDaysOfMonth.TypeEnum;
    /**
     * Time of day when recurring scanning window commences (24h format)
     */
    start_time: string;
    /**
     * Time of day when recurring scanning window ends (24h format)
     */
    end_time: string;
    /**
     * Days of month when recurring scanning window should be active (`1 - 31`).
     * If selected day is not applicable to the month, the nearest date will be used instead.
     * E.g. a scan set to run on the \"30th\" will run February 28th. For API consumer's convenience `31`
     * will ALWAYS be considered as the  END_OF_MONTH wildcard.
     */
    days_of_month: number[];
}

export declare namespace AlScanWindowSelectedDaysOfMonth {
    export type TypeEnum = 'days_of_month';
    const typeEnum: {
        Month: "days_of_month";
    };
}

/**
 * Scan window for selected days of week, with daily start and end times.
 * Effectively the window will be active every day according to `days_of_week` list,
 * between specified times `start_time` and `end_time`.
 */
export declare interface AlScanWindowSelectedDaysOfWeek extends AlScanWindow {
    type: AlScanWindowSelectedDaysOfWeek.TypeEnum;
    /**
     * Time of day when recurring scanning window commences (24h format)
     */
    start_time: string;
    /**
     * Time of day when recurring scanning window ends (24h format)
     */
    end_time: string;
    /**
     * Days of week when recurring scanning window should be active (`1 - 7`, where `1` is Monday and `7` is Sunday)
     */
    days_of_week: number[];
}

export declare namespace AlScanWindowSelectedDaysOfWeek {
    export type TypeEnum = 'days_of_week';
    const typeEnum: {
        Week: "days_of_week";
    };
}

/**
 * Scan window for selected weekday of month, with a start and end times.
 * The window will be active on a specific nth weekday of a month such as the 2nd Monday
 * where the scan will start at or shortly after the given start_time until end_time.
 * In case start_time is bigger than end_time the scan will continue to the following day.
 */
export declare interface AlScanWindowSelectedWeekdayOfMonth extends AlScanWindow {
    type: AlScanWindowSelectedWeekdayOfMonth.TypeEnum;
    /**
     * Time of day when scan window commences (24h format)
     */
    start_time: string;
    /**
     * Time of day when scan window ends (24h format). If the value is
     * smaller than start_time it means window is active till the next day.
     */
    end_time: string;
    /**
     * The day of the week the scan will occur on
     */
    day_of_week: AlScanWindowSelectedWeekdayOfMonth.DayOfWeekEnum;
    /**
     * The nth of that weekday of that month the scan will start on (e.g. 2nd)
     */
    nth_week: AlScanWindowSelectedWeekdayOfMonth.NthWeekEnum;
}

export declare namespace AlScanWindowSelectedWeekdayOfMonth {
    export type TypeEnum = 'weekday_of_month';
    const typeEnum: {
        Month: "weekday_of_month";
    };
    export type DayOfWeekEnum = 1 | 2 | 3 | 4 | 5 | 6 | 7;
    const dayOfWeekEnum: {
        NUMBER_1: DayOfWeekEnum;
        NUMBER_2: DayOfWeekEnum;
        NUMBER_3: DayOfWeekEnum;
        NUMBER_4: DayOfWeekEnum;
        NUMBER_5: DayOfWeekEnum;
        NUMBER_6: DayOfWeekEnum;
        NUMBER_7: DayOfWeekEnum;
    };
    export type NthWeekEnum = 1 | 2 | 3 | 4;
    const nthWeekEnum: {
        NUMBER_1: NthWeekEnum;
        NUMBER_2: NthWeekEnum;
        NUMBER_3: NthWeekEnum;
        NUMBER_4: NthWeekEnum;
    };
}

/**
 * Scan window for specific date and time (e.g. 10/Jun/2020 15:20).
 */
export declare interface AlScanWindowSpecificDate extends AlScanWindow {
    type: AlScanWindowSpecificDate.TypeEnum;
    /**
     * Specific date (`dd.mm.yyyy` format) when scan window starts.
     */
    start_date: string;
    /**
     * Time of day when specific date scanning window commences (24h format, `HH:MM`)
     */
    start_time: string;
    /**
     * Specific date (`dd.mm.yyyy` format) when scan window ends.
     */
    end_date: string | null;
    /**
     * Time of day when continuous scanning window ends (24h format, `HH:MM`)
     */
    end_time: string | null;
}

export declare namespace AlScanWindowSpecificDate {
    export type TypeEnum = 'specific_date';
    const typeEnum: {
        Date: "specific_date";
    };
}

export declare const AlSchedulerClient: AlSchedulerClientInstance;

export declare class AlSchedulerClientInstance {
    private serviceName;
    private serviceVersion;
    constructor();
    getScanStatusSummary(accountId: string, deploymentId: string, queryParams?: {
        vpc_key: string;
    }): Promise<ScanStatusSummary>;
    getScanTargets(accountId: string, deploymentId: string): Promise<ScanTarget[]>;
    scanAsset(accountId: string, deploymentId: string, assetKey: string, force?: boolean): Promise<void>;
}

export declare interface AlTagScopeItem {
    type: 'tag';
    name: string;
    value: string;
}

/**
 * Describes a timezone that can be used in `ScanWindow` object.
 */
export declare interface AlTimeZone {
    /**
     * Should be used in `ScanWindow.timezone` field.
     */
    tz_name?: string;
    status?: AlTimeZone.StatusEnum;
    utc_offset?: string;
    dst_offset?: string;
    /**
     * Optional field, for informational purposes and applicable only for timezones with `Alias` status.
     */
    tz_link?: string;
    /**
     * boolean describing whether or not the timezone is currently in daylight saving time
     */
    dst: boolean;
}

export declare namespace AlTimeZone {
    export type StatusEnum = 'Canonical' | 'Alias';
    const statusEnum: {
        Canonical: StatusEnum;
        Alias: StatusEnum;
    };
}

export declare const AlWatchlistClient: AlWatchlistClientInstance;

export declare class AlWatchlistClientInstance {
    private serviceName;
    private serviceVersion;
    constructor();
    add(accountId: string, deploymentId: string, userId: string, assetKey: string): Promise<WatchList>;
    remove(accountId: string, userId: string, assetKey: string): Promise<void>;
}

export declare const AlWhitelistClient: AlwsWhitelistClientInstance;

export declare class AlwsWhitelistClientInstance {
    private serviceName;
    private serviceVersion;
    constructor();
    listTags(accountId: string, deploymentId: string): Promise<WhiteListTag[]>;
    addTag(accountId: string, deploymentId: string, tag: WhiteListTag): Promise<WhiteListTag>;
    deleteTag(accountId: string, deploymentId: string, tag: WhiteListTag): Promise<void>;
}

export declare enum AssetType {
    cidr = "cidr",
    asset = "asset",
    tag = "tag"
}

export declare interface AWSRole {
    platform_type: 'aws';
    role_type: 'ci_full' | 'cd_full' | 'ci_x_account_ct' | 'ci_readonly' | 'ci_essentials' | 'ci_manual';
    role_version?: string;
    arn?: string;
    external_id?: string;
}

export declare interface AWSRoleValidationResponse {
    status?: string;
    message?: string;
    version?: string;
}

export declare enum BlackoutsResolution {
    weekly = "weekly",
    monthly = "monthly",
    exact_date = "exact_date",
    permanent = "permanent"
}

export declare class CidrType {
    id: string;
    protocol: string;
    cidr: string;
    port: string;
    networkKey: string;
    asset_type: string;
    description: string;
    static import(rawData: any): CidrType;
}

export declare type DeployedCollectorUpdateResponse = {
    id: string;
    credential_id: string;
};

export declare enum DetailsFeature {
    scan = "scan",
    ids = "ids"
}

export declare class ExclusionsAssets {
    type: AssetType;
    asset_type?: string;
    value?: string;
    key?: string;
    constructor();
    static import(rawData: any): ExclusionsAssets;
}

export declare class ExclusionsBlackouts {
    resolution: BlackoutsResolution;
    day_of_week?: number[];
    day_of_month?: number[];
    date?: string;
    start_time?: string;
    end_time?: string;
    constructor();
    static import(rawData: any): ExclusionsBlackouts;
}

export declare class ExclusionsModified {
    at?: number;
    by?: string;
    constructor();
    static import(rawData: any): ExclusionsModified;
}

export declare class ExclusionsRulesDescriptor {
    id?: string;
    name: string;
    description: string;
    enabled: boolean;
    features: Array<string>;
    blackouts: ExclusionsBlackouts[];
    assets: ExclusionsAssets[];
    details?: ExlusionsDetails[];
    modified?: ExclusionsModified[];
    constructor();
    static import(rawData: any): ExclusionsRulesDescriptor;
    update(rule: ExclusionsRulesDescriptor): void;
}

export declare class ExclusionsRulesSnapshot {
    rules: Array<ExclusionsRulesDescriptor>;
    /**
     *  @method ExclusionsRulesSnapshot.import
     *
     *  This method expects to receive the raw object response from exclusions endpoint
     *  /exclusions/v1/{accountId}/{deploymentId}/rules
     *  It returns a populated instance of type ExclusionsRulesSnapshot.
     */
    static import(rawData: any): ExclusionsRulesSnapshot;
}

export declare class ExlusionsDetails {
    feature: DetailsFeature;
    scan_type?: ScanType;
    port?: string;
    ports?: any[];
    proto?: Protocols;
    cidr?: string;
    constructor();
    static import(rawData: any): ExlusionsDetails;
}

export declare type fimAssetType = "region" | "vpc" | "subnet" | "host" | "tag";

export declare type fimConfigType = "nix_dir" | "win_dir" | "win_reg";

export declare type fimMonitoredOperation = "create" | "modify" | "attrib" | "remove";

export declare type fimPathType = 'monitored_paths' | 'excluded_paths';

/**
 * Returns the fist 'policy.byParam 'that matches 'value'.
 * The match criteria is not case sensitive.
 */
export declare function findPolicy(policies: Policy[], byParam: string, value: string): Policy | undefined;

export declare function getFullPath(config: AlFimConfiguration): string;

export declare const nixRegex: RegExp;

export declare const OTISClient: OTISClient_2;

declare class OTISClient_2 {
    private client;
    private serviceName;
    private version;
    /**
     * Create Option
     */
    createOption(accountId: string, data: TuningOption): Promise<TuningOption>;
    /**
     * Get Option
     */
    getOption(accountId: string, optionId: string): Promise<TuningOption>;
    /**
     * List Options
     */
    listOptions(accountId: string, params?: {
        [key: string]: string | string[];
    }): Promise<TuningOption[]>;
    /**
     * Delete Option
     */
    deleteOption(accountId: string, optionId: string): Promise<void>;
    /**
     * Update Option Value
     *
     * value: set as any because of the API flexibility, from docs: value - arbitrary JSON data
     */
    updateOptionValue(accountId: string, optionId: string, value: TuningOptionValue): Promise<TuningOption>;
    /**
     * Resolve Option Values
     */
    resolveOptionValues(accountId: string, data: {
        scope: TuningOptionScope;
        names: string[];
    }): Promise<unknown>;
}

export declare const OtisClientV2: OtisClientV2_2;

declare class OtisClientV2_2 {
    private client;
    private serviceName;
    private version;
    /**
     * Create Option
     */
    createOption(accountId: string, data: TuningOption): Promise<TuningOption>;
    /**
     * Get Option
     */
    getOption(accountId: string, optionId: string): Promise<TuningOption>;
    /**
     * List Options
     */
    listOptions(accountId: string, params?: {
        [key: string]: string | string[];
    }): Promise<TuningOption[]>;
    /**
     * Delete Option
     */
    deleteOption(accountId: string, optionId: string): Promise<void>;
    /**
     * Update Option Value
     *
     * value: set as any because of the API flexibility, from docs: value - arbitrary JSON data
     */
    updateOptionValue(accountId: string, optionId: string, value: TuningOptionValue): Promise<TuningOption>;
    /**
     * Resolve Option Values
     */
    resolveOptionValues(accountId: string, data: {
        scope: TuningOptionScope;
        names: string[];
    }): Promise<unknown>;
}

export declare function parseNodeFlavor(flavorValue: string): string;

/**
 * These two functions perform opposite operations.
 * Policy name is transform to  node flavor once the whitespaces have bee replace with '-'.
 */
export declare function parsePolicyName(policyName: string): string;

export declare interface Policy {
    name: string;
    id: string;
    product_family: string;
    features: PolicyFeature[];
    udr_type: string;
    policy_rank: number;
}

declare interface PolicyFeature {
    type: string;
}

export declare enum Protocols {
    tcp = "tcp",
    udp = "udp",
    icmp = "icmp",
    asterisk = "*"
}

declare type QParams = {
    [q: string]: string | number | boolean;
} | {};

export declare interface ScanOptionPort {
    /**
     * The required `proto` parameter allows to specify a protocol that will be used during scan for the ports selection.
     * Supported options are:   - u: UDP protocol   - t: TCP protocol   - tu: both TCP & UDP protocols
     */
    proto?: ScanOptionPort.protoEnum;
}

export declare namespace ScanOptionPort {
    export type protoEnum = 't' | 'u' | 'tu';
    const protoEnum: {
        T: protoEnum;
        U: protoEnum;
        Tu: protoEnum;
    };
}

export declare interface ScanOptionPortRange extends ScanOptionPort {
    ranges: string[];
}

export declare namespace ScanOptionPortRange {
}

/**
 * Scan Option allowing to specify a list of ports or port ranges that will be probed during scan.
 * Please note this option is only applicable for Internal and External vulnerability scans.
 * If no ScanOptionPort option is specified scan will use full port range
 */
export declare interface ScanOptionPorts {
    scan_ports?: (ScanOptionPortSingle | ScanOptionPortRange | ScanOptionPortWildcard)[];
}

export declare interface ScanOptionPortSingle extends ScanOptionPort {
    ports: number[];
}

export declare namespace ScanOptionPortSingle {
}

export declare interface ScanOptionPortWildcard extends ScanOptionPort {
    value: ScanOptionPortWildcard.valueEnum;
}

export declare namespace ScanOptionPortWildcard {
    export type valueEnum = 'common' | '*' | 'typically_vulnerable' | 'all';
    const valueEnum: {
        Common: valueEnum;
        Star: valueEnum;
        TypicallyVulnerable: valueEnum;
        All: valueEnum;
    };
}

export declare interface ScanStatusSummary {
    summary: {
        total?: number;
        in_scope?: number;
        excluded?: number;
        running?: number;
        scanned?: number;
        scannable?: number;
    };
}

export declare interface ScanTarget {
    id?: string;
    type?: string;
    policy?: {
        ports?: number[];
        credentials?: any;
    };
    subnet?: string;
    address?: string;
    name?: string;
    vpc?: string;
    metadata?: {
        request_id: string;
        status?: string;
        excluded?: boolean;
        last_scan?: number;
        last_heartbeat?: number;
        launch_time?: number;
        priority?: number;
    };
}

export declare enum ScanType {
    vulnerability = "vulnerability",
    pci = "pci",
    discovery = "discovery",
    external = "external"
}

export declare const ThemisClient: ThemisClient_2;

declare class ThemisClient_2 {
    private serviceName;
    constructor();
    getRole(accountId: string, platformType: 'aws' | 'azure', roleType: 'ci_full' | 'cd_full' | 'ci_x_account_ct' | 'ci_readonly' | 'ci_essentials' | 'ci_manual', roleVersion: string): Promise<ThemisRoleDocument>;
    getRoles(accountId: string): Promise<{
        roles: ThemisRoleDocument[];
    }>;
    validateRoleCredentials(accountId: string, awsRole: AWSRole): Promise<AWSRoleValidationResponse>;
}

export declare interface ThemisRoleDocument {
    type?: 'ci_full' | 'cd_full' | 'ci_x_account_ct' | 'ci_readonly' | 'ci_essentials' | 'ci_manual';
    platform_type?: 'aws' | 'azure';
    policy_document?: any;
    external_id?: string;
    aws_account_id?: string;
    version?: string;
    cft?: {
        s3_bucket?: string;
        s3_key?: string;
        s3_url?: string;
    };
}

/**
 *  TimeScheduleDescriptor provides a class to describe any schedule time, along with its
 *  raw properties and annotations.
 */
export declare class TimeScheduleDescriptor {
    isCertainHoursChecked: boolean;
    hourWindow: string;
    hours: string;
    minutes: string;
    constructor(rawData: any);
}

export declare interface TuningOption {
    id?: string;
    name?: string;
    scope?: TuningOptionScope;
    value?: TuningOptionValue;
}

export declare interface TuningOptionScope {
    deployment_id?: string;
    region_key?: string;
    vpc_key?: string;
    vpc_id?: string;
    provider_type?: string;
    provider_id?: string;
}

export declare type TuningOptionValue = string | number | boolean | {
    [key: string]: unknown;
};

export declare type WatchList = {
    [key: string]: WatchlistItem;
};

export declare interface WatchlistItem {
    id?: string;
    key?: string;
    account_id?: string;
    added_on?: number;
    created_on?: number;
    deleted_on?: number;
    deployment_id?: string;
    environment_id?: string;
    name?: string;
    type?: string;
    user_id?: string;
}

export declare interface WhiteListTag {
    tag_key?: string;
    tag_value?: string;
    type?: 'tag';
}

export declare const windowsDirectoryRegex: RegExp;

export declare const windowsRegistryRegex: RegExp;

export { }
