import { AIMSAccount } from '@al/core';
import { AIMSOrganization } from '@al/core';
import { AlCardstackCharacteristics } from '@al/core/cardstack';
import { AlCardstackPropertyDescriptor } from '@al/core/cardstack';
import { AlCardstackValueDescriptor } from '@al/core/cardstack';
import { AlCorrelationRuleV2 } from '@al/core/search';
import { AlHeraldAccountSubscriptionV2 } from '@al/core/reporting';
import { AlHeraldSubscribersV2 } from '@al/core/reporting';
import { AlIntegrationConnection } from '@al/core/reporting';
import { AlResponderExecutionsHistoryResultAggregations } from '@al/core/reporting';
import { ScheduledReportV2 } from '@al/core/reporting';

export declare class AetherClientInstance {
    private serviceName;
    constructor();
    /**
     * Exposures Search
     * POST
     * /aether/exposures/2013-01-01/search
     * "https://api.cloudinsight.alertlogic.com/aether/exposures/2013-01-01/search"
     *
     * Please note that this is a provisional method and subject to imminent change.
     *
     * @param query The search string, or null.
     * @param advanced Optional, configuration parameters for sorting, paging & criteria
     */
    search(query: string, advanced?: {
        parser?: string;
        options?: string;
        size?: number;
        sort?: string;
        start?: number;
        format?: string;
        cursor?: string;
        fq?: string;
        facet?: string;
    }): Promise<AetherSearchResponse>;
}

export declare interface AetherResult {
    id?: string;
    fields?: {
        impact?: string;
        engine?: string;
        cvss_vector?: string;
        description?: string;
        cpe_names?: string[];
        origin_id?: string;
        pci_exception_reason?: string;
        resolution?: string;
        name?: string;
        pci_severity?: string;
        last_modified?: string;
        supported_platforms?: string[];
        cvss_score?: string;
        cve?: string;
        cwe?: string;
        reference?: string;
        severity?: string;
        cvss_scores_list?: string[];
    };
}

export declare interface AetherSearchResponse {
    status?: {
        rid?: string;
        'time-ms'?: number;
    };
    hits?: {
        found?: number;
        start?: number;
        cursor?: string;
        hit?: AetherResult[];
    };
    facets?: {
        [property: string]: {
            value: string;
            count: number;
        }[];
    };
}

declare interface AgentTicket {
    id?: string;
    subject?: string;
    description?: string;
    assignee_id?: string;
    end_customer?: string;
    impact?: string;
    priority?: string;
    security_clearance?: string;
    resolution_call?: string;
    kba_status?: string;
    breach?: string;
    urgency?: string;
    origin?: string;
    feature?: string;
}

/**
 * Nothing is complete without at least two aliases
 */
declare const AlAetherClient: AetherClientInstance;
export { AlAetherClient as ALAether }
export { AlAetherClient as AetherClient }
export { AlAetherClient }

export declare interface AlAlertDefinition {
    id: string;
    caption: string;
    properties: unknown;
}

export declare const AlCollectorStatusClient: AlCollectorStatusClientInstance;

export declare class AlCollectorStatusClientInstance {
    protected serviceVersion: string;
    protected serviceName: string;
    constructor();
    /**
     * List, group and aggregate statuses
     * GET
     * /collectors_status/v1/{account_id}/statuses/{status_id}/history
     *
     * */
    getCollectorStatusHistory(accountId: string, statusId: string, params?: AlCollectorStatusQueryParams): Promise<Array<AlCollectorStatusObject>>;
    /**
     * Get last status
     * Returns last status by status_id, identical to the query /collectors_status/v1/{account_id}/statuses/{status_id}/history?limit=1
     * GET
     * /collectors_status/v1/{account_id}/statuses/{status_id}
     *
     * */
    getCollectorLastStatus(accountId: string, statusId: string, params?: AlCollectorStatusQueryParams): Promise<AlCollectorStatusHistoryResponse>;
    /**
     * Report status
     * Endpoint for reporting status of a collector.
     * PUT
     * /collectors_status/v1/{account_id}/statuses/{status_id}/streams/{stream}
     *
     * */
    reportCollectorStatus(accountId: string, statusId: string, stream: string, payload: AlCollectorStatusObject): Promise<void>;
}

export declare interface AlCollectorStatusHistoryResponse {
    rows: number;
    status_id: string;
    statuses: Array<AlCollectorStatusObject>;
}

export declare interface AlCollectorStatusObject {
    timestamp: number;
    account_id?: string;
    status_id?: string;
    stream?: StreamType;
    status?: Status;
    reported_by?: string;
    inst_type?: string;
    details?: string[];
    source_id?: string;
    stream_type?: string;
    stream_name?: string;
    status_type?: string;
    message_type?: string;
    host_uuid?: string;
    data?: {
        [key: string]: string;
    }[];
    collection_type?: string;
    agent_type?: string;
    source_uuid?: string;
    type?: string;
    status_key?: string;
    reasons?: unknown[];
    metadata?: unknown;
    condition?: string;
    application?: string;
    errorinfo?: {
        details: {
            [key: string]: string;
        }[];
        description: string;
        code: string;
    };
}

export declare interface AlCollectorStatusQueryParams {
    adapter?: 'ingest' | 'assets' | 'sources';
    group_by?: GroupBy;
    limit?: number;
    from_ts?: number;
    until_ts?: number;
    aggregation_policy: string;
}

export declare interface AlEEPMappingDictionary {
    rules: {
        [ruleId: string]: {
            name: string;
            description: string;
            malwareStopped: string[];
        };
    };
}

export declare interface AlEndpointDetail {
    id: string;
    secondaryStatus: string;
    vtModeSupportedStates: string[];
    hasUserViewed: boolean;
    machineName: string;
    organizationId: string;
    state: string;
    latestIncident: string;
    latestActive: string;
    incidentCount: number;
    creationDate: string;
    pendingState: string;
    agentVersion: string;
    systemInformation: AlEndpointsSystemInformation;
    healthStatusErrorCodes: any[];
    lastSeen: string;
    lastStateChange: string;
    upgradeState: string;
    lastUpgradeStateChange: string;
    vtScriptRun: boolean;
    status: string;
    tags: string[];
    priority: string;
    isMasterImage: boolean;
    product: string;
    presence: string;
    isHealthy: boolean;
    effectivePriority: string;
    isServer: boolean;
    primaryStatus: string;
    endpointShadowCache: {
        desired: {
            networkIsolationState: string;
        };
        reported: {
            networkIsolationState: string;
        };
    };
}

export declare interface AlEndpointsAgentVersionInfo {
    orgRVAgent: string | null;
    orgKimya: string | null;
    globalKimya: string | null;
    globalRVAgent: string | null;
}

export declare const AlEndpointsClient: AlEndpointsClientInstance;

export declare class AlEndpointsClientInstance {
    private organizationMap;
    constructor();
    /**
     * Retrieve linked organization
     */
    getAccountOrganizationFromAIMS(accountId: string): Promise<AIMSOrganization>;
    getAccountOrganization(accountId: string): Promise<AIMSOrganization>;
    getAccountOrganizationId(accountId: string): Promise<string>;
    getAllAgentVersions(accountId: string): Promise<AlEndpointsAgentVersionInfo>;
    getMappingDictionary(accountId: string): Promise<AlEEPMappingDictionary>;
    getIncidentGroups(accountId: string): Promise<AlEndpointsGroupedIncidents>;
    getEndpointDetails(accountId: string): Promise<AlEndpointDetail[]>;
    getEndpointsSummary(accountId: string): Promise<AlEndpointsSummaryData>;
    private getEsbApiOrigin;
    /**
     * This method will attempt to override the final URL constructed based on whether the acting account
     * has access to an esb service endpoint, otherwise the default construction based on AlLocation.EndpointsAPI location will be used.
     */
    private buildRequestDescriptor;
}

export declare interface AlEndpointsGroupedIncidents {
    incidents: AlEndpointsIncidentWithContext[];
    groups: AlEndpointsIncidentGroup[];
}

export declare interface AlEndpointsIncident {
    id: number;
    alternateId: string;
    organizationid: string;
    endpointId: string;
    type: string;
    hostname: string;
    user: string;
    prevented: boolean;
    protectionState: string;
    automatedQuarantineState: string;
    processInformation?: any;
    systemInformation?: AlEndpointsSystemInformation;
    scanId?: string;
    eventType?: string;
    masterIncidentId?: number;
    overridden: boolean;
}

export declare interface AlEndpointsIncidentGroup {
    masterIncidentId: number;
    incidents: number[];
}

export declare interface AlEndpointsIncidentWithContext {
    incident: AlEndpointsIncident;
    currentDeviceState: string;
    deviceName: string;
    effectivePriority: string;
    hasUserViewed: boolean;
}

export declare interface AlEndpointsSummaryData {
    stateBreakdown: {
        primaryState: {
            INACTIVE: number;
            ERROR: number;
            ARCHIVED: number;
            OFF: number;
            ON: number;
            INSTALLING: number;
        };
        secondaryState: {
            UPGRADE_NEEDED_WITH_STATUS_OFF: number;
            UPGRADE_NEEDED_WITH_STATUS_ON: number;
            UPGRADE_IN_PROGRESS_WITH_STATUS_OFF: number;
            PENDING_PROTECTION_CHANGE_WITH_STATUS_OFF: number;
            VIRTUALIZATION_NOT_SUPPORTED_BUT_INSTALLED_WITH_STATUS_OFF: number;
            INACTIVE_WITH_STATUS_ON: number;
            REBOOT_REQUIRED: number;
            INSTALLATION_IN_PROGRESS: number;
            UPGRADE_IN_PROGRESS_WITH_STATUS_ON: number;
            MANUALLY_ENABLE_VIRTUALIZATION_WITH_STATUS_OFF: number;
            REBOOT_REQUIRED_WITH_STATUS_ON: number;
            THIRTYTWO_BIT_UNSUPPORTED_BUT_INSTALLED_WITH_STATUS_ON: number;
            VT_MODE_OFF_STATUS_ON: number;
            DISABLE_HYPERV: number;
            MANUALLY_ENABLE_VIRTUALIZATION_WITH_STATUS_ON: number;
            THIRTYTWO_BIT_UNSUPPORTED_BUT_INSTALLED_WITH_STATUS_OFF: number;
            PENDING_PROTECTION_CHANGE_WITH_STATUS_ON: number;
            VIRTUALIZATION_NOT_SUPPORTED_BUT_INSTALLED_WITH_STATUS_ON: number;
            ACTIVE: number;
            HARDWARE_NOT_SUPPORTED_BUT_INSTALLED_WITH_STATUS_OFF: number;
            DISABLE_HYPERV_WITH_STATUS_ON: number;
            THIRTYTWO_BIT_UNSUPPORTED: number;
            CPU_NOT_SUPPORTED: number;
            VT_MODE_OFF_STATUS_OFF: number;
            INACTIVE_WITH_STATUS_OFF: number;
            DISABLE_HYPERV_WITH_STATUS_OFF: number;
            PROTECTION_TURNED_OFF: number;
            REBOOT_REQUIRED_WITH_STATUS_OFF: number;
            RAPIDVISOR_UNINSTALLED: number;
            HARDWARE_NOT_SUPPORTED_BUT_INSTALLED_WITH_STATUS_ON: number;
            VIRTUALIZATION_NOT_SUPPORTED_BUT_INSTALLED: number;
            MANUALLY_ENABLE_VIRTUALIZATION: number;
            INACTIVE_WITH_STATUS_ARCHIVED: number;
            THIRTYTWO_BIT_UNSUPPORTED_BUT_INSTALLED: number;
            VIRTUALIZATION_NOT_SUPPORTED: number;
            RAPIDVISOR_ERROR: number;
            HARDWARE_NOT_SUPPORTED_BUT_INSTALLED: number;
        };
    };
    currencyBreakdown: {
        current: number;
        outOfDate: number;
    };
    checkinBreakdown: {
        online: number;
        recent: number;
        notRecently: number;
    };
    platformBreakdown: {
        platformFamily: string;
        platformName: string;
        count: number;
    }[];
    osBreakdown: {
        os: string;
        versions: {
            osName: string;
            osVersion: string;
            count: number;
        }[];
    }[];
    responseBreakdown: {
        isolated: number;
        quarantined: number;
        overridden: number;
        unresolved: number;
    };
    incidentTypes: {
        ruleName: string;
        monitoredCount: number;
        protectCount: number;
    }[];
    endpointsWithIncidents: {
        endpointId: string;
        endpointName: string;
        monitoredCount: number;
        protectCount: number;
    }[];
    usersWithIncidents: {
        username: string;
        monitoredCount: number;
        protectCount: number;
    }[];
    totalIncidents: number;
    totalProtectIncidents: number;
    totalMonitoredIncidents: number;
    totalEndpoints: number;
    totalUsers: number;
}

export declare interface AlEndpointsSystemInformation {
    manufacturer: string;
    productName: string;
    memory: string;
    os: string;
    numberOfCPUs: number;
    cpuModels: string[];
    dotnetFrameworkVersions: any[];
}

export declare class AlGenericAlertDefinition implements AlAlertDefinition {
    id: string;
    caption: string;
    type: AlNotificationTypeDescriptor;
    properties: AlIncidentAlertProperties & AlScheduledReportProperties & AlHealthAlertProperties;
    constructor(origin?: AlAlertDefinition);
    static fromSubscription(subscription: AlHeraldAccountSubscriptionV2, inheritFrom?: AlAlertDefinition): AlGenericAlertDefinition;
    static fromSchedule(schedule: ScheduledReportV2, inheritFrom?: AlAlertDefinition): AlGenericAlertDefinition;
    mergeSubscription(subscription: AlHeraldAccountSubscriptionV2): void;
    mergeSchedule(schedule: ScheduledReportV2): void;
}

export declare interface AlGenericAlertOptions {
    accounts?: AIMSAccount[];
    threatLevels?: AlThreatLevel[];
    connections?: AlIntegrationConnection[];
}

export declare const ALGestalt: AlGestaltClientInstance;

export declare class AlGestaltClientInstance {
    protected serviceStack: string;
    constructor();
    /**
     * Get gestalt canary to check if gestalt is responding.
     * This gestalt API endpoint is used by datadog.
     * GET
     * /canary
     *
     *  @returns a promise
     */
    isGestaltResponding(): Promise<any>;
}

export declare const AlGestaltDashboardsClient: AlGestaltDashboardsClientInstance;

declare class AlGestaltDashboardsClientInstance {
    protected serviceStack: string;
    protected serviceName: string;
    protected serviceVersion: string;
    constructor();
    /**
     * get triggers trends and the trigger ids
     * GET
     * /dashboard/v1/:account_id/automated_response/trigger_trends
     * "https://gestalt-api.product.dev.alertlogic.com/dashboard/v1/:account_id/automated_response/trigger_trends"
     *
     * @param accountId AIMS Account ID
     * @param timeRange start and end time
     * @returns a promise with the trigger trends and triggers involved
     */
    getTriggersTrends(accountId: string, params?: AlTriggerTimeRangeParams): Promise<AlTriggerTrends[]>;
}

export declare const ALGestaltNotifications: AlGestaltNotificationsClientInstance;

export declare class AlGestaltNotificationsClientInstance implements AlGestaltNotificationsClientInterface {
    protected serviceStack: string;
    protected serviceName: string;
    protected serviceVersion: string;
    constructor();
    /**
     * Updates user's subscription in a given account, feature and subkey
     * GET
     * /notifications/v1/:account_id/options/incident
     * "https://gestalt-api.product.dev.alertlogic.com/notifications/v1/2/options/incident"
     *
     * @param accountId AIMS Account ID
     * @param entity
     * @returns a promise with the subscriptions
     */
    getGenericAlertOptions(accountId: string, entity: string): Promise<AlGenericAlertOptions>;
    /**
     * get characteristics for an entity and an account
     * GET
     * /notifications/v1/:account_id/characteristics/incident
     * "https://gestalt-api.product.dev.alertlogic.com/notifications/v1/2/characteristics/incident"
     *
     * @param accountId AIMS Account ID
     * @param entity incident
     * @returns a promise with the subscriptions
     */
    getNotificationsCharacteristics(accountId: string, entity: string): Promise<AlCardstackCharacteristics>;
    /**
     * get list for an entity and an account
     * GET
     * /notifications/v1/:account_id/list/incident
     * "https://gestalt-api.product.dev.alertlogic.com/notifications/v1/2/list/incident"
     *
     * @param accountId AIMS Account ID
     * @param entity incident
     * @returns a promise with the subscriptions
     */
    getNotificationsList(accountId: string, entity: string, version?: number, params?: {
        sortField?: string;
        sortDirection?: string;
    }): Promise<AlAlertDefinition[]>;
    /**
     * deletes the browser cache for this GET request.
     * GET
     * /notifications/v1/:account_id/list/:entity
     * "https://gestalt-api.product.dev.alertlogic.com/notifications/v1/2/list/incident"
     *
     * @param accountId AIMS Account ID
     * @param entity Could be incident or schedule
     * @returns a promise
     */
    deleteNotificationsListCache(accountId: string, entity: string): Promise<void>;
    /**
     * remove an entity
     * DELETE
     * /notifications/v1/:account_id/entity/:entityType
     * https://gestalt-api.product.dev.alertlogic.com/notifications/v1/2/entity/:entityType
     *
     * @param accountId AIMS Account ID
     * @param entity incident
     * @param ids list of ids to delete
     */
    deleteEntity(accountId: string, hierarchyType: string, ids: string[]): Promise<boolean>;
}

declare interface AlGestaltNotificationsClientInterface {
    getGenericAlertOptions(accountId: string, entity: string): Promise<AlGenericAlertOptions>;
    getNotificationsCharacteristics(accountId: string, entity: string): Promise<AlCardstackCharacteristics>;
    getNotificationsList(accountId: string, entity: string): Promise<AlAlertDefinition[]>;
    deleteEntity(accountId: string, hierarchyType: string, ids: string[]): Promise<boolean>;
}

export declare interface AlHealthAlertProperties extends AlNotificationCommonProperties {
    deployments?: string[];
}

export declare type AlHeraldNotificationType = "unknown/unknown" | "incidents/alerts" | "observations/notification" | "tableau/notifications" | "search/notifications" | "health/alerts";

export declare interface AlIncidentAlertProperties extends AlNotificationCommonProperties {
    threatLevel?: string[];
    escalated?: boolean;
    correlation?: AlCorrelationRuleV2;
}

/** Alert notifications */
export declare interface AlNotificationCommonProperties {
    id: string;
    caption: string;
    toptitle?: string;
    subtitle?: string;
    createdTime?: number;
    createdBy?: string;
    modifiedTime?: number;
    modifiedBy?: string;
    accountId?: string;
    subscribers?: AlHeraldSubscribersV2[];
    filters?: object | any;
    filtersParsed?: any;
    active?: boolean;
    lastMessageSent?: number;
    emailSubject?: string;
    webhookPayload?: string;
    externalId?: string;
    notificationType?: string;
    searchables?: string[];
    error?: string;
    createdByName?: string;
    modifiedByName?: string;
    accounts?: string[];
    accountsName?: {
        name: string;
        isCreator: boolean;
    }[];
    usersName?: {
        name: string;
        isCreator: boolean;
    }[];
    users?: string[];
    integrationsName?: string[];
    integrations?: string[];
    recipientsTotal?: number;
    playbooksName?: string[];
    playbooks?: string[];
}

export declare interface AlNotificationTypeDescriptor {
    entityCode: string;
    notificationType: AlHeraldNotificationType;
    group: "alert" | "scheduled";
    unimplemented?: boolean;
    pseudoType?: boolean;
}

export declare const alNotificationTypeDictionary: {
    [entityCode: string]: AlNotificationTypeDescriptor;
};

export declare interface AlScheduledReportProperties extends AlNotificationCommonProperties {
    workbookSubMenu?: string;
    workbookId?: string;
    viewId?: string;
    siteId?: string;
    schedule?: object | any;
    format?: string;
    reportFilters?: any;
    workbookName?: string;
    viewName?: string;
    cadenceName?: 'daily' | 'weekly' | 'monthly' | 'every_15_minutes' | 'asap';
    artifactCount?: number;
    embedUrl?: string;
    contentUrl?: string;
    runTime?: number;
    reportFiltersSort?: string[];
}

export declare interface AlThreatLevel {
    value: string;
    caption: string;
}

export declare interface AlTriggerTimeRangeParams {
    startTime?: number;
    endTime?: number;
}

export declare interface AlTriggerTrends {
    triggers?: {
        [key: string]: string;
    };
    aggregations?: AlResponderExecutionsHistoryResultAggregations;
}

export declare const alUnknownNotificationType: AlNotificationTypeDescriptor;

declare interface CallbackResponse {
    id?: string;
    url?: string;
}

export declare class CharacteristicsHandler {
    private accountId;
    private entityType;
    constructor(accountId: string, entityType: string);
    static handle(accountId: string, entityType: string): Promise<AlCardstackCharacteristics>;
    private handleInternal;
    private manageScheduledCharacteristics;
    private manageAlertCharacteristics;
    private incidentAlertCharacteristics;
    private scheduledReportCharacteristics;
    private artifactsCharacteristics;
    /**
     * process aims, iris and herald to make the filter definition with values for incidents
     */
    private prepareManageAlertsFiltersDefinitions;
    private prepareManageScheduledFiltersDefinitions;
    /**
     * process aims, iris and herald to make the filter definition with values for incidents
     */
    private prepareIncidentsFiltersDefinitions;
    /**
     * process aims, cargo to make the filter definition with values for incidents
     */
    private prepareScheduleFiltersDefinitions;
    /**
     * process cargo and tacoma to make the filter definition with values for artifacts
     */
    private prepareArtifactsFiltersDefinitions;
    private buildCategoryDictionaries;
    private mapFieldToValueDesc;
    private prepareTacomaFilters;
}

export declare class CharacteristicsUtility {
    static getCaptionDefinition(): AlCardstackPropertyDescriptor;
    static getAccountsDefinition(): AlCardstackPropertyDescriptor;
    static getAccountIdDefinition(): AlCardstackPropertyDescriptor;
    static getRecipientDefinition(): AlCardstackPropertyDescriptor;
    static getUsersDefinition(): AlCardstackPropertyDescriptor;
    static getIntegrationsDefinition(): AlCardstackPropertyDescriptor;
    static getWorkbookSubMenuDefinition(): AlCardstackPropertyDescriptor;
    static getWorkbookBySubMenuDefinition(): AlCardstackPropertyDescriptor;
    static getWorkbookIdDefinition(): AlCardstackPropertyDescriptor;
    static getViewIdDefinition(): AlCardstackPropertyDescriptor;
    static getSearchableDefinition(): AlCardstackPropertyDescriptor;
    static getScheduleCadenceDefinition(): AlCardstackPropertyDescriptor;
    static getScheduleNameDefinition(): AlCardstackPropertyDescriptor;
    static getDisplayDefinition(): AlCardstackPropertyDescriptor;
    static getCreatedTimeDefinition(): AlCardstackPropertyDescriptor;
    static getModifiedTimeDefinition(): AlCardstackPropertyDescriptor;
    static getNotificationType(): AlCardstackPropertyDescriptor;
    static getThreatLevelDefinition(): AlCardstackPropertyDescriptor;
    static getEscalatedDefinition(): AlCardstackPropertyDescriptor;
    static getScheduledTimeDefinition(): AlCardstackPropertyDescriptor;
    static getDeploymentsDefinition(): AlCardstackPropertyDescriptor;
    /**
     * Return display hardcode values
     * @param property
     */
    static getDisplayValues(property: string): AlCardstackValueDescriptor[];
    /**
     * Return escalated hardcode values
     * @param property
     */
    static getEscalatedValues(property: string): AlCardstackValueDescriptor[];
    /**
     * Return posible static values for scheduling cadence
     * @param property
     */
    static getScheduleCadenceValues(property: string): AlCardstackValueDescriptor[];
    /**
     * Create a property in a dictionary if that does not exists
     * @param dictionary
     * @param key
     * @param name
     */
    static createPropertyDictionary(dictionary: {
        [key: string]: {
            name: string;
            metadata: unknown;
        };
    }, key: string, name: string, metadata?: {
        [property: string]: unknown;
    }): void;
    /**
     * Create an array of properties from a dictionary key:value
     * @param dictionaryIn
     * @param property
     */
    static fromDictionaryToAlCardstackValueDescriptor(dictionaryIn: {
        [key: string]: {
            name: string;
            metadata: {
                [property: string]: unknown;
            };
        };
    }, property: string): AlCardstackValueDescriptor[];
    /**
     * create AlCardstackValueDescriptor  from objects with id and name
     */
    static processWithIdAndName(list: {
        id?: string | boolean;
        name?: string;
    }[], property: string, type?: string): AlCardstackValueDescriptor[];
    /** sort list by caption */
    static sortValueDescriptorList<T, K extends keyof T>(values: T[], field: K): T[];
    /**
     * create a object with the AlCardstackValueDescriptor structure
     */
    static createAlCardstackValueDescriptor(item: {
        value: string | boolean;
        caption: string;
        type?: string;
        metadata?: {
            [property: string]: unknown;
        };
    }, property: string): AlCardstackValueDescriptor;
    static validateEntitlement(accountId: string, entitlement: string): Promise<boolean>;
}

declare type GroupBy = 'host_id' | 'stream' | 'source_id' | 'collection_type';

declare interface KinesisResponse {
    id?: string;
    stream_name?: string;
    tributary_id?: string;
}

export declare class ListHandler {
    private accountId;
    private entityType?;
    private params?;
    constructor(accountId: string, entityType?: string, params?: SortParams);
    static handle(accountId: string, entityType: string, params?: SortParams): Promise<AlGenericAlertDefinition[]>;
    private handleInternal;
    private alertList;
    private scheduledReportList;
}

export declare interface SortParams {
    sortField?: string;
    sortDirection?: string;
}

export declare type Status = "new" | "offline" | "ok" | "error" | "warning";

export declare type StreamType = "offline" | "tmhost" | "syslog" | "tmappliance" | "update" | "updater" | "undefined" | "default";

declare interface Ticket {
    ticket_id?: string;
    subject?: string;
    description?: string;
    breach?: string;
    urgency?: string;
    partner_ticket_id?: string;
    issue_type?: string;
    product?: string;
    end_customer?: string;
    created_at?: string;
    updated_at?: string;
}

declare interface TicketComment {
    id?: string;
    comment?: string;
    created_at?: string;
}

declare interface TicketComments {
    ticket_id?: string;
    comments?: TicketComment[];
    next_page?: number;
    count?: number;
}

declare interface TicketsResponse {
    tickets: Ticket[];
}

export declare const TMClient: TMClient_2;

declare class TMClient_2 {
    private client;
    private serviceName;
    /**
     * Create agent ticket
     * POST
     * /tickets/v1/agents
     * "https://api.global.alertlogic.com/tickets/v1/agents"
     * -d '{"subject":"Problem subject", "comment": {"body": "Problem description"}, "assignee_id":12345678, "end_customer":"Valued Customer", "main_product":"p2"}'
     */
    createAgentTicket(id?: string, subject?: string, description?: string, assigneeId?: string, endCustomer?: string, problemSummary?: string, sensorName?: string, sensorId?: string, heimdallAccount?: string, feature?: string, priority?: string, impact?: string, breach?: string, urgency?: string, kbaStatus?: string, category?: string, resolutionCall?: string, issueType?: string, experience?: string, securityClearance?: string, origin?: string, product?: string, mainProduct?: string): Promise<AgentTicket>;
    /**
     * Create ticket
     * POST
     * /tickets/v1/:account_id/tickets
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets"
     * -d '{"subject":"Problem Subject", "comment":"Problem description", "partner_ticket_id":"32844660"}'
     */
    createTicket(accountId: string, subject: string, comment: string, partnerTicketId: string): Promise<Ticket>;
    /**
     * Get ticket
     * GET
     * /tickets/v1/:account_id/tickets/:ticket_id
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets/4481"
     */
    getTicket(accountId: string, ticketId: string): Promise<Ticket>;
    /**
     * Get ticket comments
     * GET
     * /tickets/v1/:account_id/tickets/:ticket_id/comments
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets/4481/comments"
     */
    getTicketComments(accountId: string, ticketId: string, queryParams?: {
        next_page?: string;
        since?: string;
        sort_by?: string;
        sort_order?: string;
    }): Promise<TicketComments>;
    /**
     * Get tickets
     * GET
     * /tickets/v1/:account_id/tickets
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets?status=pending"
     */
    getTickets(accountId: string, queryParams?: {
        next_page?: string;
        status?: string;
        sort_by?: string;
        sort_order?: string;
    }): Promise<TicketsResponse>;
    /**
     * Update a ticket
     * PUT
     * /tickets/v1/:account_id/tickets/:ticket_id
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets/4481"
     * -d '{"comment":"additional ticket comment"}'
     */
    updateTicket(accountId: string, ticketId: string, comment?: string, partnerTicketId?: string): Promise<Ticket>;
    /**
     * Register Callback URL
     * POST
     * /tickets/v1/:account_id/updates/tickets/callback
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets/callback"
     * -d '{"url":"https://www.example.com/callback"}'
     */
    registerCallback(accountId: string, url: string): Promise<CallbackResponse>;
    /**
     * Register for Kinesis Updates
     * POST
     * /tickets/v1/:account_id/updates/tickets/kinesis
     * "https://api.global.alertlogic.com/tickets/v1/01000001/tickets/kinesis"
     * -d '{"stream_name":"exampleStreamName", "tributary_id":"8F0A29FD-4D28-428C-8CC2-7A68CB64FEB3"}'
     */
    registerKinesis(accountId: string, streamName: string, tributaryId?: string): Promise<KinesisResponse>;
}

export { }
