@lbrlabs/pulumi-dynatrace/types/output.d.ts

A Pulumi package for creating and managing Dynatrace cloud resources.

import * as outputs from "../types/output";
export interface AlertingFilters {
    /**
     * A conditions for the metric usage
     */
    filters?: outputs.AlertingFiltersFilter[];
}
export interface AlertingFiltersFilter {
    custom?: outputs.AlertingFiltersFilterCustom;
    predefined?: outputs.AlertingFiltersFilterPredefined;
}
export interface AlertingFiltersFilterCustom {
    description?: outputs.AlertingFiltersFilterCustomDescription;
    metadata?: outputs.AlertingFiltersFilterCustomMetadata;
    title?: outputs.AlertingFiltersFilterCustomTitle;
}
export interface AlertingFiltersFilterCustomDescription {
    caseSensitive?: boolean;
    enabled?: boolean;
    negate?: boolean;
    operator: string;
    value: string;
}
export interface AlertingFiltersFilterCustomMetadata {
    items: outputs.AlertingFiltersFilterCustomMetadataItems;
}
export interface AlertingFiltersFilterCustomMetadataItems {
    filters: outputs.AlertingFiltersFilterCustomMetadataItemsFilter[];
}
export interface AlertingFiltersFilterCustomMetadataItemsFilter {
    key: string;
    value: string;
}
export interface AlertingFiltersFilterCustomTitle {
    caseSensitive?: boolean;
    enabled?: boolean;
    negate?: boolean;
    operator: string;
    value: string;
}
export interface AlertingFiltersFilterPredefined {
    negate?: boolean;
    type: string;
}
export interface AlertingProfileEventTypeFilter {
    /**
     * Configuration of a custom event filter. Filters custom events by title or description. If both specified, the AND logic applies
     */
    customEventFilters?: outputs.AlertingProfileEventTypeFilterCustomEventFilter[];
    /**
     * Configuration of a custom event filter. Filters custom events by title or description. If both specified, the AND logic applies
     */
    predefinedEventFilters?: outputs.AlertingProfileEventTypeFilterPredefinedEventFilter[];
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
}
export interface AlertingProfileEventTypeFilterCustomEventFilter {
    customDescriptionFilters?: outputs.AlertingProfileEventTypeFilterCustomEventFilterCustomDescriptionFilter[];
    customTitleFilters?: outputs.AlertingProfileEventTypeFilterCustomEventFilterCustomTitleFilter[];
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
}
export interface AlertingProfileEventTypeFilterCustomEventFilterCustomDescriptionFilter {
    caseInsensitive?: boolean;
    enabled?: boolean;
    negate?: boolean;
    operator: string;
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
    value: string;
}
export interface AlertingProfileEventTypeFilterCustomEventFilterCustomTitleFilter {
    caseInsensitive?: boolean;
    enabled?: boolean;
    negate?: boolean;
    operator: string;
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
    value: string;
}
export interface AlertingProfileEventTypeFilterPredefinedEventFilter {
    eventType: string;
    negate?: boolean;
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
}
export interface AlertingProfileMetadata {
    /**
     * Dynatrace server version
     */
    clusterVersion?: string;
    /**
     * A Sorted list of the version numbers of the configuration
     */
    configurationVersions?: number[];
    /**
     * A Sorted list of the version numbers of the configuration
     */
    currentConfigurationVersions?: string[];
}
export interface AlertingProfileRule {
    /**
     * Send a notification if a problem remains open longer than *X* minutes
     */
    delayInMinutes: number;
    /**
     * The severity level to trigger the alert. Possible values are `AVAILABILITY`,	`CUSTOM_ALERT`,	`ERROR`,`MONITORING_UNAVAILABLE`,`PERFORMANCE` and `RESOURCE_CONTENTION`.
     */
    severityLevel: string;
    /**
     * Configuration of the tag filtering of the alerting profile
     */
    tagFilters: outputs.AlertingProfileRuleTagFilter[];
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
}
export interface AlertingProfileRuleTagFilter {
    includeMode: string;
    tagFilters?: outputs.AlertingProfileRuleTagFilterTagFilter[];
    /**
     * allows for configuring properties that are not explicitly supported by the current version of this provider
     */
    unknowns?: string;
}
export interface AlertingProfileRuleTagFilterTagFilter {
    context: string;
    key: string;
    value?: string;
}
export interface AlertingRules {
    /**
     * A conditions for the metric usage
     */
    rules?: outputs.AlertingRulesRule[];
}
export interface AlertingRulesRule {
    delayInMinutes: number;
    includeMode: string;
    severityLevel: string;
    tags?: string[];
}
export interface ApiDetectionConditions {
    conditions: outputs.ApiDetectionConditionsCondition[];
}
export interface ApiDetectionConditionsCondition {
    base: string;
    matcher: string;
    pattern: string;
}
export interface ApplicationAnomaliesFailureRate {
    /**
     * Parameters of failure rate increase auto-detection. Example: If the expected error rate is 1.5%, and you set an absolute increase of 1%, and a relative increase of 50%, the thresholds will be:  Absolute: 1.5% + **1%** = 2.5%  Relative: 1.5% + 1.5% * **50%** = 2.25%
     */
    auto?: outputs.ApplicationAnomaliesFailureRateAuto;
    /**
     * Fixed thresholds for failure rate increase detection
     */
    thresholds?: outputs.ApplicationAnomaliesFailureRateThresholds;
}
export interface ApplicationAnomaliesFailureRateAuto {
    absolute: number;
    relative: number;
    unknowns?: string;
}
export interface ApplicationAnomaliesFailureRateThresholds {
    sensitivity: string;
    threshold: number;
    unknowns?: string;
}
export interface ApplicationAnomaliesResponseTime {
    /**
     * Parameters of the response time degradation auto-detection. Violation of **any** criterion triggers an alert
     */
    auto?: outputs.ApplicationAnomaliesResponseTimeAuto;
    /**
     * Fixed thresholds for response time degradation detection
     */
    thresholds?: outputs.ApplicationAnomaliesResponseTimeThresholds;
}
export interface ApplicationAnomaliesResponseTimeAuto {
    load: string;
    milliseconds: number;
    percent: number;
    slowestMilliseconds: number;
    slowestPercent: number;
    unknowns?: string;
}
export interface ApplicationAnomaliesResponseTimeThresholds {
    load: string;
    milliseconds: number;
    sensitivity: string;
    slowestMilliseconds: number;
    unknowns?: string;
}
export interface ApplicationAnomaliesTraffic {
    /**
     * The configuration of traffic drops detection
     */
    drops?: outputs.ApplicationAnomaliesTrafficDrops;
    /**
     * The configuration of traffic spikes detection
     */
    spikes?: outputs.ApplicationAnomaliesTrafficSpikes;
}
export interface ApplicationAnomaliesTrafficDrops {
    enabled: boolean;
    percent?: number;
}
export interface ApplicationAnomaliesTrafficSpikes {
    enabled: boolean;
    percent?: number;
}
export interface ApplicationDataPrivacySessionReplayDataPrivacy {
    /**
     * (Field has overlap with `dynatrace.SessionReplayWebPrivacy`) Content masking settings for Session Replay.
     */
    contentMaskingSettings: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettings;
    optIn?: boolean;
    urlExclusionRules?: string[];
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettings {
    playback: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsPlayback;
    recording: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsRecording;
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsPlayback {
    preset: string;
    rules?: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsPlaybackRules;
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsPlaybackRules {
    rules: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsPlaybackRulesRule[];
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsPlaybackRulesRule {
    selector: string;
    type: string;
    userInteractionHidden?: boolean;
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsRecording {
    preset: string;
    rules?: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsRecordingRules;
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsRecordingRules {
    rules: outputs.ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsRecordingRulesRule[];
}
export interface ApplicationDataPrivacySessionReplayDataPrivacyContentMaskingSettingsRecordingRulesRule {
    selector: string;
    type: string;
    userInteractionHidden?: boolean;
}
export interface ApplicationDetectionRuleFilterConfig {
    /**
     * Where to look for the pattern value, possible values are `DOMAIN` or `URL`
     */
    applicationMatchTarget: string;
    /**
     * The operator used for matching the application detection rule, possible values are `BEGINS_WITH`, `CONTAINS`, `ENDS_WITH`, `EQUALS`, `MATCHES`
     */
    applicationMatchType: string;
    /**
     * The value to look for with the application detection rule
     */
    pattern: string;
}
export interface ApplicationErrorRulesCustomErrors {
    /**
     * Configuration of the custom error in the web application
     */
    rules: outputs.ApplicationErrorRulesCustomErrorsRule[];
}
export interface ApplicationErrorRulesCustomErrorsRule {
    capture?: boolean;
    customAlerting?: boolean;
    impactApdex?: boolean;
    keyMatcher?: string;
    keyPattern?: string;
    valueMatcher?: string;
    valuePattern?: string;
}
export interface ApplicationErrorRulesHttpErrors {
    /**
     * Configuration of the HTTP error in the web application
     */
    rules: outputs.ApplicationErrorRulesHttpErrorsRule[];
}
export interface ApplicationErrorRulesHttpErrorsRule {
    capture?: boolean;
    considerBlockedRequests?: boolean;
    considerForAi?: boolean;
    considerUnknownErrorCode?: boolean;
    errorCodes?: string;
    filter?: string;
    filterByUrl?: boolean;
    impactApdex?: boolean;
    url?: string;
}
export interface AutotagEntitySelectorBasedRule {
    enabled?: boolean;
    normalization?: string;
    selector?: string;
    unknowns?: string;
    valueFormat?: string;
}
export interface AutotagRule {
    conditions?: outputs.AutotagRuleCondition[];
    enabled?: boolean;
    normalization?: string;
    propagationTypes?: string[];
    type: string;
    unknowns?: string;
    valueFormat?: string;
}
export interface AutotagRuleCondition {
    /**
     * @deprecated You should use 'application_type' instead of 'application_type_comparison'. This attribute still exists for backwards compatibility.
     */
    applicationTypeComparisons?: outputs.AutotagRuleConditionApplicationTypeComparison[];
    applicationTypes?: outputs.AutotagRuleConditionApplicationType[];
    azureComputeModeComparisons?: outputs.AutotagRuleConditionAzureComputeModeComparison[];
    /**
     * @deprecated You should use 'azure_compute_mode' instead of 'azure_compute_mode_comparison'. This attribute still exists for backwards compatibility.
     */
    azureComputeModes?: outputs.AutotagRuleConditionAzureComputeMode[];
    /**
     * @deprecated You should use 'azure_sku' instead of 'azure_sku_comparision'. This attribute still exists for backwards compatibility.
     */
    azureSkuComparisions?: outputs.AutotagRuleConditionAzureSkuComparision[];
    azureSkus?: outputs.AutotagRuleConditionAzureSkus[];
    /**
     * @deprecated You should use 'comparison' instead of 'base_comparison_basic'. This attribute still exists for backwards compatibility.
     */
    baseComparisonBasics?: outputs.AutotagRuleConditionBaseComparisonBasic[];
    /**
     * @deprecated 'base_condition_key' is deprecated. You should use 'key'
     */
    baseConditionKeys?: outputs.AutotagRuleConditionBaseConditionKey[];
    /**
     * @deprecated You should use 'bitness' instead of 'bitness_comparision'. This attribute still exists for backwards compatibility.
     */
    bitnessComparisions?: outputs.AutotagRuleConditionBitnessComparision[];
    bitnesses?: outputs.AutotagRuleConditionBitness[];
    /**
     * @deprecated You should use 'cloud_type' instead of 'cloud_type_comparison'. This attribute still exists for backwards compatibility.
     */
    cloudTypeComparisons?: outputs.AutotagRuleConditionCloudTypeComparison[];
    cloudTypes?: outputs.AutotagRuleConditionCloudType[];
    comparisons?: outputs.AutotagRuleConditionComparison[];
    /**
     * @deprecated You should use 'custom_application_type' instead of 'custom_application_type_comparison'. This attribute still exists for backwards compatibility.
     */
    customApplicationTypeComparisons?: outputs.AutotagRuleConditionCustomApplicationTypeComparison[];
    customApplicationTypes?: outputs.AutotagRuleConditionCustomApplicationType[];
    /**
     * @deprecated 'custom_host_metadata_condition_key' is deprecated. You should use 'custom_host_metadata'
     */
    customHostMetadataConditionKeys?: outputs.AutotagRuleConditionCustomHostMetadataConditionKey[];
    customHostMetadatas?: outputs.AutotagRuleConditionCustomHostMetadata[];
    /**
     * @deprecated 'custom_process_metadata_condition_key' is deprecated. You should use 'custom_process_metadata'
     */
    customProcessMetadataConditionKeys?: outputs.AutotagRuleConditionCustomProcessMetadataConditionKey[];
    customProcessMetadatas?: outputs.AutotagRuleConditionCustomProcessMetadata[];
    databaseTopologies?: outputs.AutotagRuleConditionDatabaseTopology[];
    /**
     * @deprecated You should use 'database_topology' instead of 'database_topology_comparison'. This attribute still exists for backwards compatibility.
     */
    databaseTopologyComparisons?: outputs.AutotagRuleConditionDatabaseTopologyComparison[];
    /**
     * @deprecated You should use 'dcrum_decoder' instead of 'dcrum_decoder_comparison'. This attribute still exists for backwards compatibility.
     */
    dcrumDecoderComparisons?: outputs.AutotagRuleConditionDcrumDecoderComparison[];
    dcrumDecoders?: outputs.AutotagRuleConditionDcrumDecoder[];
    entities?: outputs.AutotagRuleConditionEntity[];
    /**
     * @deprecated You should use 'entity' instead of 'entity_id_comparison'. This attribute still exists for backwards compatibility.
     */
    entityIdComparisons?: outputs.AutotagRuleConditionEntityIdComparison[];
    hostTeches?: outputs.AutotagRuleConditionHostTech[];
    /**
     * @deprecated `hypervisor_type_comparision` is deprecated. Use `hypervisor` instead
     */
    hypervisorTypeComparisions?: outputs.AutotagRuleConditionHypervisorTypeComparision[];
    hypervisors?: outputs.AutotagRuleConditionHypervisor[];
    /**
     * @deprecated You should use 'indexed_name' instead of 'indexed_name_comparison'. This attribute still exists for backwards compatibility.
     */
    indexedNameComparisons?: outputs.AutotagRuleConditionIndexedNameComparison[];
    indexedNames?: outputs.AutotagRuleConditionIndexedName[];
    /**
     * @deprecated You should use 'indexed_string' instead of 'indexed_string_comparison'. This attribute still exists for backwards compatibility.
     */
    indexedStringComparisons?: outputs.AutotagRuleConditionIndexedStringComparison[];
    indexedStrings?: outputs.AutotagRuleConditionIndexedString[];
    /**
     * @deprecated You should use 'indexed_tag' instead of 'indexed_tag_comparison'. This attribute still exists for backwards compatibility.
     */
    indexedTagComparisons?: outputs.AutotagRuleConditionIndexedTagComparison[];
    indexedTags?: outputs.AutotagRuleConditionIndexedTag[];
    /**
     * @deprecated You should use 'integer' instead of 'integer_comparison'. This attribute still exists for backwards compatibility.
     */
    integerComparisons?: outputs.AutotagRuleConditionIntegerComparison[];
    integers?: outputs.AutotagRuleConditionInteger[];
    /**
     * @deprecated You should use 'ipaddress' instead of 'ipaddress_comparison'. This attribute still exists for backwards compatibility.
     */
    ipaddressComparisons?: outputs.AutotagRuleConditionIpaddressComparison[];
    ipaddresses?: outputs.AutotagRuleConditionIpaddress[];
    keys?: outputs.AutotagRuleConditionKey[];
    /**
     * @deprecated You should use 'mobile_platform' instead of 'mobile_platform_comparison'. This attribute still exists for backwards compatibility.
     */
    mobilePlatformComparisons?: outputs.AutotagRuleConditionMobilePlatformComparison[];
    mobilePlatforms?: outputs.AutotagRuleConditionMobilePlatform[];
    osArches?: outputs.AutotagRuleConditionOsArch[];
    osTypes?: outputs.AutotagRuleConditionOsType[];
    /**
     * @deprecated You should use 'os_arch' instead of 'osarchitecture_comparison'. This attribute still exists for backwards compatibility.
     */
    osarchitectureComparisons?: outputs.AutotagRuleConditionOsarchitectureComparison[];
    /**
     * @deprecated You should use 'os_type' instead of 'ostype_comparison'. This attribute still exists for backwards compatibility.
     */
    ostypeComparisons?: outputs.AutotagRuleConditionOstypeComparison[];
    /**
     * @deprecated You should use 'paas_type' instead of 'paas_type_comparison'. This attribute still exists for backwards compatibility.
     */
    paasTypeComparisons?: outputs.AutotagRuleConditionPaasTypeComparison[];
    paasTypes?: outputs.AutotagRuleConditionPaasType[];
    /**
     * @deprecated 'process_metadata_condition_key' is deprecated. You should use 'process_metadata'
     */
    processMetadataConditionKeys?: outputs.AutotagRuleConditionProcessMetadataConditionKey[];
    processMetadatas?: outputs.AutotagRuleConditionProcessMetadata[];
    serviceTopologies?: outputs.AutotagRuleConditionServiceTopology[];
    /**
     * @deprecated You should use 'service_topology' instead of 'service_topology_comparison'. This attribute still exists for backwards compatibility.
     */
    serviceTopologyComparisons?: outputs.AutotagRuleConditionServiceTopologyComparison[];
    /**
     * @deprecated You should use 'service_type' instead of 'service_type_comparison'. This attribute still exists for backwards compatibility.
     */
    serviceTypeComparisons?: outputs.AutotagRuleConditionServiceTypeComparison[];
    serviceTypes?: outputs.AutotagRuleConditionServiceType[];
    /**
     * @deprecated You should use 'host_tech' instead of 'simple_host_tech_comparison'. This attribute still exists for backwards compatibility.
     */
    simpleHostTechComparisons?: outputs.AutotagRuleConditionSimpleHostTechComparison[];
    /**
     * @deprecated You should use 'tech' instead of 'simple_tech_comparison'. This attribute still exists for backwards compatibility.
     */
    simpleTechComparisons?: outputs.AutotagRuleConditionSimpleTechComparison[];
    /**
     * @deprecated You should use 'string' instead of 'string_comparison'. This attribute still exists for backwards compatibility.
     */
    stringComparisons?: outputs.AutotagRuleConditionStringComparison[];
    /**
     * @deprecated 'string_condition_key' is deprecated. You should use 'string_key'
     */
    stringConditionKeys?: outputs.AutotagRuleConditionStringConditionKey[];
    stringKeys?: outputs.AutotagRuleConditionStringKey[];
    strings?: outputs.AutotagRuleConditionString[];
    /**
     * @deprecated You should use 'synthetic_engine' instead of 'synthetic_engine_type_comparison'. This attribute still exists for backwards compatibility.
     */
    syntheticEngineTypeComparisons?: outputs.AutotagRuleConditionSyntheticEngineTypeComparison[];
    syntheticEngines?: outputs.AutotagRuleConditionSyntheticEngine[];
    /**
     * @deprecated You should use 'tag' instead of 'tag_comparison'. This attribute still exists for backwards compatibility.
     */
    tagComparisons?: outputs.AutotagRuleConditionTagComparison[];
    tags?: outputs.AutotagRuleConditionTag[];
    teches?: outputs.AutotagRuleConditionTech[];
    unknowns?: string;
}
export interface AutotagRuleConditionApplicationType {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionApplicationTypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionAzureComputeMode {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionAzureComputeModeComparison {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionAzureSkuComparision {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionAzureSkus {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionBaseComparisonBasic {
    negate?: boolean;
    type: string;
    unknowns?: string;
}
export interface AutotagRuleConditionBaseConditionKey {
    attribute: string;
    type?: string;
    unknowns?: string;
}
export interface AutotagRuleConditionBitness {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionBitnessComparision {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionCloudType {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionCloudTypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionComparison {
    negate?: boolean;
    type: string;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomApplicationType {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionCustomApplicationTypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionCustomHostMetadata {
    attribute: string;
    dynamicKey: outputs.AutotagRuleConditionCustomHostMetadataDynamicKey;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomHostMetadataConditionKey {
    attribute: string;
    dynamicKey: outputs.AutotagRuleConditionCustomHostMetadataConditionKeyDynamicKey;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomHostMetadataConditionKeyDynamicKey {
    key: string;
    source: string;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomHostMetadataDynamicKey {
    key: string;
    source: string;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomProcessMetadata {
    attribute: string;
    dynamicKey: outputs.AutotagRuleConditionCustomProcessMetadataDynamicKey;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomProcessMetadataConditionKey {
    attribute: string;
    dynamicKey: outputs.AutotagRuleConditionCustomProcessMetadataConditionKeyDynamicKey;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomProcessMetadataConditionKeyDynamicKey {
    key: string;
    source: string;
    unknowns?: string;
}
export interface AutotagRuleConditionCustomProcessMetadataDynamicKey {
    key: string;
    source: string;
    unknowns?: string;
}
export interface AutotagRuleConditionDatabaseTopology {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionDatabaseTopologyComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionDcrumDecoder {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionDcrumDecoderComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionEntity {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionEntityIdComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionHostTech {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionHostTechValue;
}
export interface AutotagRuleConditionHostTechValue {
    type?: string;
    unknowns?: string;
    verbatimType?: string;
}
export interface AutotagRuleConditionHypervisor {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionHypervisorTypeComparision {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIndexedName {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIndexedNameComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIndexedString {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIndexedStringComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIndexedTag {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionIndexedTagValue;
}
export interface AutotagRuleConditionIndexedTagComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionIndexedTagComparisonValue;
}
export interface AutotagRuleConditionIndexedTagComparisonValue {
    context: string;
    key: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIndexedTagValue {
    context: string;
    key: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionInteger {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: number;
}
export interface AutotagRuleConditionIntegerComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: number;
}
export interface AutotagRuleConditionIpaddress {
    caseSensitive?: boolean;
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionIpaddressComparison {
    caseSensitive?: boolean;
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionKey {
    attribute: string;
    type?: string;
    unknowns?: string;
}
export interface AutotagRuleConditionMobilePlatform {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionMobilePlatformComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionOsArch {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionOsType {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionOsarchitectureComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionOstypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionPaasType {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionPaasTypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionProcessMetadata {
    attribute: string;
    dynamicKey: string;
    unknowns?: string;
}
export interface AutotagRuleConditionProcessMetadataConditionKey {
    attribute: string;
    dynamicKey: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
}
export interface AutotagRuleConditionServiceTopology {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionServiceTopologyComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionServiceType {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionServiceTypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionSimpleHostTechComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionSimpleHostTechComparisonValue;
}
export interface AutotagRuleConditionSimpleHostTechComparisonValue {
    type?: string;
    unknowns?: string;
    verbatimType?: string;
}
export interface AutotagRuleConditionSimpleTechComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionSimpleTechComparisonValue;
}
export interface AutotagRuleConditionSimpleTechComparisonValue {
    type?: string;
    unknowns?: string;
    verbatimType?: string;
}
export interface AutotagRuleConditionString {
    caseSensitive?: boolean;
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionStringComparison {
    caseSensitive?: boolean;
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionStringConditionKey {
    attribute: string;
    dynamicKey: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
}
export interface AutotagRuleConditionStringKey {
    attribute: string;
    dynamicKey: string;
    unknowns?: string;
}
export interface AutotagRuleConditionSyntheticEngine {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionSyntheticEngineTypeComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionTag {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionTagValue;
}
export interface AutotagRuleConditionTagComparison {
    negate?: boolean;
    operator: string;
    /**
     * @deprecated The value of the attribute type is implicit, therefore shouldn't get specified
     */
    type?: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionTagComparisonValue;
}
export interface AutotagRuleConditionTagComparisonValue {
    context: string;
    key: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionTagValue {
    context: string;
    key: string;
    unknowns?: string;
    value?: string;
}
export interface AutotagRuleConditionTech {
    negate?: boolean;
    operator: string;
    unknowns?: string;
    value?: outputs.AutotagRuleConditionTechValue;
}
export interface AutotagRuleConditionTechValue {
    type?: string;
    unknowns?: string;
    verbatimType?: string;
}
export interface AutotagV2Rules {
    rules: outputs.AutotagV2RulesRule[];
}
export interface AutotagV2RulesRule {
    attributeRule?: outputs.AutotagV2RulesRuleAttributeRule;
    enabled: boolean;
    entitySelector?: string;
    type: string;
    valueFormat?: string;
    valueNormalization: string;
}
export interface AutotagV2RulesRuleAttributeRule {
    azureToPgpropagation?: boolean;
    azureToServicePropagation?: boolean;
    conditions: outputs.AutotagV2RulesRuleAttributeRuleConditions;
    entityType: string;
    hostToPgpropagation?: boolean;
    pgToHostPropagation?: boolean;
    pgToServicePropagation?: boolean;
    serviceToHostPropagation?: boolean;
    serviceToPgpropagation?: boolean;
}
export interface AutotagV2RulesRuleAttributeRuleConditions {
    conditions: outputs.AutotagV2RulesRuleAttributeRuleConditionsCondition[];
}
export interface AutotagV2RulesRuleAttributeRuleConditionsCondition {
    caseSensitive?: boolean;
    dynamicKey?: string;
    dynamicKeySource?: string;
    entityId?: string;
    enumValue?: string;
    integerValue?: number;
    key: string;
    operator: string;
    stringValue?: string;
    tag?: string;
}
export interface AwsAnomaliesEc2CandidateHighCpuDetection {
    /**
     * Alert if the condition is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesEc2CandidateHighCpuDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesEc2CandidateHighCpuDetectionCustomThresholds {
    cpuUsage: number;
}
export interface AwsAnomaliesElbHighConnectionErrorsDetection {
    /**
     * Alert if the condition is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesElbHighConnectionErrorsDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesElbHighConnectionErrorsDetectionCustomThresholds {
    connectionErrorsPerMinute: number;
}
export interface AwsAnomaliesLambdaHighErrorRateDetection {
    /**
     * Alert if the condition is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesLambdaHighErrorRateDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesLambdaHighErrorRateDetectionCustomThresholds {
    failedInvocationsRate: number;
}
export interface AwsAnomaliesRdsHighCpuDetection {
    /**
     * Alert if the condition is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesRdsHighCpuDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesRdsHighCpuDetectionCustomThresholds {
    cpuUsage: number;
}
export interface AwsAnomaliesRdsHighMemoryDetection {
    /**
     * Alert if **both** conditions is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesRdsHighMemoryDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesRdsHighMemoryDetectionCustomThresholds {
    freeMemory: number;
    swapUsage: number;
}
export interface AwsAnomaliesRdsHighWriteReadLatencyDetection {
    /**
     * Alert if the condition is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesRdsHighWriteReadLatencyDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesRdsHighWriteReadLatencyDetectionCustomThresholds {
    readWriteLatency: number;
}
export interface AwsAnomaliesRdsLowStorageDetection {
    /**
     * Alert if the condition is met in 3 out of 5 samples
     */
    customThresholds?: outputs.AwsAnomaliesRdsLowStorageDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesRdsLowStorageDetectionCustomThresholds {
    freeStoragePercentage: number;
}
export interface AwsAnomaliesRdsRestartsSequenceDetection {
    /**
     * Alert if the condition is met in 2 out of 20 samples
     */
    customThresholds?: outputs.AwsAnomaliesRdsRestartsSequenceDetectionCustomThresholds;
    /**
     * Possible Values: `Auto`, `Custom`
     */
    detectionMode?: string;
    /**
     * This setting is enabled (`true`) or disabled (`false`)
     */
    enabled: boolean;
}
export interface AwsAnomaliesRdsRestartsSequenceDetectionCustomThresholds {
    restartsPerMinute: number;
}
export interface AwsCredentialsAuthenticationData {
    /**
     * the access key
     */
    accessKey?: string;
    /**
     * the ID of the Amazon account
     */
    accountId?: string;
    /**
     * (Read only) the external ID token for setting an IAM role. You can obtain it with the `GET /aws/iamExternalId` request
     */
    externalId: string;
    /**
     * the IAM role to be used by Dynatrace to get monitoring data
     */
    iamRole?: string;
    /**
     * the secret access key
     */
    secretKey?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
}
export interface AwsCredentialsSupportingServicesToMonitor {
    /**
     * a list of metrics to be monitored for this service
     */
    monitoredMetrics?: outputs.AwsCredentialsSupportingServicesToMonitorMonitoredMetric[];
    /**
     * the name of the supporting service
     */
    name?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
}
export interface AwsCredentialsSupportingServicesToMonitorMonitoredMetric {
    dimensions?: string[];
    name?: string;
    statistic?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
}
export interface AwsCredentialsTagsToMonitor {
    /**
     * the key of the AWS tag.
     */
    name?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
    /**
     * the value of the AWS tag
     */
    value?: string;
}
export interface AzureCredentialsMonitorOnlyExcludingTagPair {
    /**
     * The name of the tag.
     */
    name?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
    /**
     * The value of the tag.   If set to `null`, then resources with any value of the tag are monitored.
     */
    value?: string;
}
export interface AzureCredentialsMonitorOnlyTagPair {
    /**
     * The name of the tag.
     */
    name?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
    /**
     * The value of the tag.   If set to `null`, then resources with any value of the tag are monitored.
     */
    value?: string;
}
export interface AzureCredentialsSupportingService {
    /**
     * A list of Azure tags to be monitored.  You can specify up to 10 tags. A resource tagged with *any* of the specified tags is monitored.  Only applicable when the **monitorOnlyTaggedEntities** parameter is set to `true`
     */
    monitoredMetrics?: outputs.AzureCredentialsSupportingServiceMonitoredMetric[];
    /**
     * The name of the supporting service.
     */
    name?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
}
export interface AzureCredentialsSupportingServiceMonitoredMetric {
    dimensions?: string[];
    name?: string;
    /**
     * Any attributes that aren't yet supported by this provider
     */
    unknowns?: string;
}
export interface BrowserMonitorAnomalyDetection {
    /**
     * Thresholds for loading times
     */
    loadingTimeThresholds?: outputs.BrowserMonitorAnomalyDetectionLoadingTimeThreshold[];
    /**
     * Outage handling configuration
     */
    outageHandlings?: outputs.BrowserMonitorAnomalyDetectionOutageHandling[];
}
export interface BrowserMonitorAnomalyDetectionLoadingTimeThreshold {
    enabled?: boolean;
    thresholds?: outputs.BrowserMonitorAnomalyDetectionLoadingTimeThresholdThreshold[];
}
export interface BrowserMonitorAnomalyDetectionLoadingTimeThresholdThreshold {
    thresholds: outputs.BrowserMonitorAnomalyDetectionLoadingTimeThresholdThresholdThreshold[];
}
export interface BrowserMonitorAnomalyDetectionLoadingTimeThresholdThresholdThreshold {
    eventIndex?: number;
    requestIndex?: number;
    type?: string;
    valueMs: number;
}
export interface BrowserMonitorAnomalyDetectionOutageHandling {
    globalOutage?: boolean;
    globalOutagePolicies?: outputs.BrowserMonitorAnomalyDetectionOutageHandlingGlobalOutagePolicy[];
    localOutage?: boolean;
    localOutagePolicies?: outputs.BrowserMonitorAnomalyDetectionOutageHandlingLocalOutagePolicy[];
    retryOnError?: boolean;
}
export interface BrowserMonitorAnomalyDetectionOutageHandlingGlobalOutagePolicy {
    consecutiveRuns: number;
}
export interface BrowserMonitorAnomalyDetectionOutageHandlingLocalOutagePolicy {
    affectedLocations: number;
    consecutiveRuns: number;
}
export interface BrowserMonitorKeyPerformanceMetrics {
    /**
     * Defines the key performance metric for load actions. Supported values are `VISUALLY_COMPLETE`, `SPEED_INDEX`, `USER_ACTION_DURATION`, `TIME_TO_FIRST_BYTE`, `HTML_DOWNLOADED`, `DOM_INTERACTIVE`, `LOAD_EVENT_START` and `LOAD_EVENT_END`.
     */
    loadActionKpm: string;
    /**
     * Defines the key performance metric for XHR actions. Supported values are `VISUALLY_COMPLETE`, `USER_ACTION_DURATION`, `TIME_TO_FIRST_BYTE` and `RESPONSE_END`.
     */
    xhrActionKpm: string;
}
export interface BrowserMonitorPerformanceThresholds {
    thresholds: outputs.BrowserMonitorPerformanceThresholdsThreshold[];
}
export interface BrowserMonitorPerformanceThresholdsThreshold {
    event: string;
    threshold: number;
}
export interface BrowserMonitorScript {
    /**
     * The setup of the monitor
     */
    configuration?: outputs.BrowserMonitorScriptConfiguration;
    /**
     * Steps of the clickpath—the first step must always be of the `navigate` type
     */
    events?: outputs.BrowserMonitorScriptEvents;
    /**
     * The type of monitor. Possible values are `clickpath` for clickpath monitors and `availability` for single-URL browser monitors. These monitors are only allowed to have one event of the `navigate` type
     */
    type: string;
}
export interface BrowserMonitorScriptConfiguration {
    bandwidth?: outputs.BrowserMonitorScriptConfigurationBandwidth;
    blocks?: string[];
    bypassCsp?: boolean;
    cookies?: outputs.BrowserMonitorScriptConfigurationCookies;
    device?: outputs.BrowserMonitorScriptConfigurationDevice;
    disableWebSecurity?: boolean;
    headers?: outputs.BrowserMonitorScriptConfigurationHeaders;
    ignoredErrorCodes?: outputs.BrowserMonitorScriptConfigurationIgnoredErrorCodes;
    javascriptSetttings?: outputs.BrowserMonitorScriptConfigurationJavascriptSetttings;
    monitorFrames?: boolean;
    userAgent?: string;
}
export interface BrowserMonitorScriptConfigurationBandwidth {
    download?: number;
    latency?: number;
    networkType?: string;
    upload?: number;
}
export interface BrowserMonitorScriptConfigurationCookies {
    cookies: outputs.BrowserMonitorScriptConfigurationCookiesCookie[];
}
export interface BrowserMonitorScriptConfigurationCookiesCookie {
    domain: string;
    name: string;
    path?: string;
    value: string;
}
export interface BrowserMonitorScriptConfigurationDevice {
    height?: number;
    mobile?: boolean;
    name?: string;
    orientation?: string;
    scaleFactor?: number;
    touchEnabled?: boolean;
    width?: number;
}
export interface BrowserMonitorScriptConfigurationHeaders {
    headers: outputs.BrowserMonitorScriptConfigurationHeadersHeader[];
    restrictions?: string[];
}
export interface BrowserMonitorScriptConfigurationHeadersHeader {
    name: string;
    value: string;
}
export interface BrowserMonitorScriptConfigurationIgnoredErrorCodes {
    matchingDocumentRequests?: string;
    statusCodes: string;
}
export interface BrowserMonitorScriptConfigurationJavascriptSetttings {
    customProperties?: string;
    timeoutSettings?: outputs.BrowserMonitorScriptConfigurationJavascriptSetttingsTimeoutSettings;
    visuallyCompleteOptions?: outputs.BrowserMonitorScriptConfigurationJavascriptSetttingsVisuallyCompleteOptions;
}
export interface BrowserMonitorScriptConfigurationJavascriptSetttingsTimeoutSettings {
    actionLimit: number;
    totalTimeout: number;
}
export interface BrowserMonitorScriptConfigurationJavascriptSetttingsVisuallyCompleteOptions {
    excludedElements?: string[];
    excludedUrls?: string[];
    imageSizeThreshold: number;
    inactivityTimeout: number;
    mutationTimeout: number;
}
export interface BrowserMonitorScriptEvents {
    events?: outputs.BrowserMonitorScriptEventsEvent[];
}
export interface BrowserMonitorScriptEventsEvent {
    click?: outputs.BrowserMonitorScriptEventsEventClick;
    cookie?: outputs.BrowserMonitorScriptEventsEventCookie;
    description: string;
    javascript?: outputs.BrowserMonitorScriptEventsEventJavascript;
    keystrokes?: outputs.BrowserMonitorScriptEventsEventKeystrokes;