## API Report File for "@azure/arm-monitor"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import * as coreAuth from '@azure/core-auth';
import * as coreClient from '@azure/core-client';
import { PagedAsyncIterableIterator } from '@azure/core-paging';
import { PollerLike } from '@azure/core-lro';
import { PollOperationState } from '@azure/core-lro';

// @public
export interface Action {
    odataType: "Microsoft.WindowsAzure.Management.Monitoring.Alerts.Models.Microsoft.AppInsights.Nexus.DataContracts.Resources.ScheduledQueryRules.AlertingAction" | "Microsoft.WindowsAzure.Management.Monitoring.Alerts.Models.Microsoft.AppInsights.Nexus.DataContracts.Resources.ScheduledQueryRules.LogToMetricAction";
}

// @public
export interface ActionDetail {
    detail?: string;
    mechanismType?: string;
    name?: string;
    sendTime?: string;
    status?: string;
    subState?: string;
}

// @public
export interface ActionGroupList {
    nextLink?: string;
    value?: ActionGroupResource[];
}

// @public
export interface ActionGroupPatchBody {
    enabled?: boolean;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export type ActionGroupResource = AzureResource & {
    groupShortName?: string;
    enabled?: boolean;
    emailReceivers?: EmailReceiver[];
    smsReceivers?: SmsReceiver[];
    webhookReceivers?: WebhookReceiver[];
    itsmReceivers?: ItsmReceiver[];
    azureAppPushReceivers?: AzureAppPushReceiver[];
    automationRunbookReceivers?: AutomationRunbookReceiver[];
    voiceReceivers?: VoiceReceiver[];
    logicAppReceivers?: LogicAppReceiver[];
    azureFunctionReceivers?: AzureFunctionReceiver[];
    armRoleReceivers?: ArmRoleReceiver[];
    eventHubReceivers?: EventHubReceiver[];
};

// @public
export interface ActionGroups {
    beginPostTestNotifications(notificationRequest: NotificationRequestBody, options?: ActionGroupsPostTestNotificationsOptionalParams): Promise<PollerLike<PollOperationState<ActionGroupsPostTestNotificationsResponse>, ActionGroupsPostTestNotificationsResponse>>;
    beginPostTestNotificationsAndWait(notificationRequest: NotificationRequestBody, options?: ActionGroupsPostTestNotificationsOptionalParams): Promise<ActionGroupsPostTestNotificationsResponse>;
    createOrUpdate(resourceGroupName: string, actionGroupName: string, actionGroup: ActionGroupResource, options?: ActionGroupsCreateOrUpdateOptionalParams): Promise<ActionGroupsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, actionGroupName: string, options?: ActionGroupsDeleteOptionalParams): Promise<void>;
    enableReceiver(resourceGroupName: string, actionGroupName: string, enableRequest: EnableRequest, options?: ActionGroupsEnableReceiverOptionalParams): Promise<void>;
    get(resourceGroupName: string, actionGroupName: string, options?: ActionGroupsGetOptionalParams): Promise<ActionGroupsGetResponse>;
    getTestNotifications(notificationId: string, options?: ActionGroupsGetTestNotificationsOptionalParams): Promise<ActionGroupsGetTestNotificationsResponse>;
    listByResourceGroup(resourceGroupName: string, options?: ActionGroupsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ActionGroupResource>;
    listBySubscriptionId(options?: ActionGroupsListBySubscriptionIdOptionalParams): PagedAsyncIterableIterator<ActionGroupResource>;
    update(resourceGroupName: string, actionGroupName: string, actionGroupPatch: ActionGroupPatchBody, options?: ActionGroupsUpdateOptionalParams): Promise<ActionGroupsUpdateResponse>;
}

// @public
export interface ActionGroupsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActionGroupsCreateOrUpdateResponse = ActionGroupResource;

// @public
export interface ActionGroupsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ActionGroupsEnableReceiverOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ActionGroupsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActionGroupsGetResponse = ActionGroupResource;

// @public
export interface ActionGroupsGetTestNotificationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActionGroupsGetTestNotificationsResponse = TestNotificationDetailsResponse;

// @public
export interface ActionGroupsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActionGroupsListByResourceGroupResponse = ActionGroupList;

// @public
export interface ActionGroupsListBySubscriptionIdOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActionGroupsListBySubscriptionIdResponse = ActionGroupList;

// @public
export interface ActionGroupsPostTestNotificationsOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type ActionGroupsPostTestNotificationsResponse = TestNotificationResponse;

// @public
export interface ActionGroupsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActionGroupsUpdateResponse = ActionGroupResource;

// @public (undocumented)
export type ActionUnion = Action | AlertingAction | LogToMetricAction;

// @public
export interface ActivityLogAlertActionGroup {
    actionGroupId: string;
    webhookProperties?: {
        [propertyName: string]: string;
    };
}

// @public
export interface ActivityLogAlertActionList {
    actionGroups?: ActivityLogAlertActionGroup[];
}

// @public
export interface ActivityLogAlertAllOfCondition {
    allOf: ActivityLogAlertLeafCondition[];
}

// @public
export interface ActivityLogAlertLeafCondition {
    equals: string;
    field: string;
}

// @public
export interface ActivityLogAlertList {
    nextLink?: string;
    value?: ActivityLogAlertResource[];
}

// @public
export interface ActivityLogAlertPatchBody {
    enabled?: boolean;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export type ActivityLogAlertResource = Resource & {
    scopes?: string[];
    enabled?: boolean;
    condition?: ActivityLogAlertAllOfCondition;
    actions?: ActivityLogAlertActionList;
    description?: string;
};

// @public
export interface ActivityLogAlerts {
    createOrUpdate(resourceGroupName: string, activityLogAlertName: string, activityLogAlert: ActivityLogAlertResource, options?: ActivityLogAlertsCreateOrUpdateOptionalParams): Promise<ActivityLogAlertsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, activityLogAlertName: string, options?: ActivityLogAlertsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, activityLogAlertName: string, options?: ActivityLogAlertsGetOptionalParams): Promise<ActivityLogAlertsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: ActivityLogAlertsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<ActivityLogAlertResource>;
    listBySubscriptionId(options?: ActivityLogAlertsListBySubscriptionIdOptionalParams): PagedAsyncIterableIterator<ActivityLogAlertResource>;
    update(resourceGroupName: string, activityLogAlertName: string, activityLogAlertPatch: ActivityLogAlertPatchBody, options?: ActivityLogAlertsUpdateOptionalParams): Promise<ActivityLogAlertsUpdateResponse>;
}

// @public
export interface ActivityLogAlertsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActivityLogAlertsCreateOrUpdateResponse = ActivityLogAlertResource;

// @public
export interface ActivityLogAlertsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ActivityLogAlertsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActivityLogAlertsGetResponse = ActivityLogAlertResource;

// @public
export interface ActivityLogAlertsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActivityLogAlertsListByResourceGroupResponse = ActivityLogAlertList;

// @public
export interface ActivityLogAlertsListBySubscriptionIdOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActivityLogAlertsListBySubscriptionIdResponse = ActivityLogAlertList;

// @public
export interface ActivityLogAlertsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ActivityLogAlertsUpdateResponse = ActivityLogAlertResource;

// @public
export interface ActivityLogs {
    list(filter: string, options?: ActivityLogsListOptionalParams): PagedAsyncIterableIterator<EventData>;
}

// @public
export interface ActivityLogsListNextOptionalParams extends coreClient.OperationOptions {
    select?: string;
}

// @public
export type ActivityLogsListNextResponse = EventDataCollection;

// @public
export interface ActivityLogsListOptionalParams extends coreClient.OperationOptions {
    select?: string;
}

// @public
export type ActivityLogsListResponse = EventDataCollection;

// @public
export type AggregationType = "None" | "Average" | "Count" | "Minimum" | "Maximum" | "Total";

// @public
export type AggregationTypeEnum = string;

// @public
export type AlertingAction = Action & {
    odataType: "Microsoft.WindowsAzure.Management.Monitoring.Alerts.Models.Microsoft.AppInsights.Nexus.DataContracts.Resources.ScheduledQueryRules.AlertingAction";
    severity: AlertSeverity;
    aznsAction?: AzNsActionGroup;
    throttlingInMin?: number;
    trigger: TriggerCondition;
};

// @public
export interface AlertRuleIncidents {
    get(resourceGroupName: string, ruleName: string, incidentName: string, options?: AlertRuleIncidentsGetOptionalParams): Promise<AlertRuleIncidentsGetResponse>;
    listByAlertRule(resourceGroupName: string, ruleName: string, options?: AlertRuleIncidentsListByAlertRuleOptionalParams): PagedAsyncIterableIterator<Incident>;
}

// @public
export interface AlertRuleIncidentsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRuleIncidentsGetResponse = Incident;

// @public
export interface AlertRuleIncidentsListByAlertRuleOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRuleIncidentsListByAlertRuleResponse = IncidentListResult;

// @public
export type AlertRuleResource = Resource & {
    namePropertiesName: string;
    description?: string;
    provisioningState?: string;
    isEnabled: boolean;
    condition: RuleConditionUnion;
    action?: RuleActionUnion;
    actions?: RuleActionUnion[];
    readonly lastUpdatedTime?: Date;
};

// @public
export interface AlertRuleResourceCollection {
    value?: AlertRuleResource[];
}

// @public
export interface AlertRuleResourcePatch {
    action?: RuleActionUnion;
    actions?: RuleActionUnion[];
    condition?: RuleConditionUnion;
    description?: string;
    isEnabled?: boolean;
    readonly lastUpdatedTime?: Date;
    name?: string;
    provisioningState?: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface AlertRules {
    createOrUpdate(resourceGroupName: string, ruleName: string, parameters: AlertRuleResource, options?: AlertRulesCreateOrUpdateOptionalParams): Promise<AlertRulesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, ruleName: string, options?: AlertRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ruleName: string, options?: AlertRulesGetOptionalParams): Promise<AlertRulesGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: AlertRulesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AlertRuleResource>;
    listBySubscription(options?: AlertRulesListBySubscriptionOptionalParams): PagedAsyncIterableIterator<AlertRuleResource>;
    update(resourceGroupName: string, ruleName: string, alertRulesResource: AlertRuleResourcePatch, options?: AlertRulesUpdateOptionalParams): Promise<AlertRulesUpdateResponse>;
}

// @public
export interface AlertRulesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRulesCreateOrUpdateResponse = AlertRuleResource;

// @public
export interface AlertRulesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AlertRulesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRulesGetResponse = AlertRuleResource;

// @public
export interface AlertRulesListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRulesListByResourceGroupResponse = AlertRuleResourceCollection;

// @public
export interface AlertRulesListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRulesListBySubscriptionResponse = AlertRuleResourceCollection;

// @public
export interface AlertRulesUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AlertRulesUpdateResponse = AlertRuleResource;

// @public
export type AlertSeverity = string;

// @public
export interface ArmRoleReceiver {
    name: string;
    roleId: string;
    useCommonAlertSchema?: boolean;
}

// @public
export interface AutomationRunbookReceiver {
    automationAccountId: string;
    isGlobalRunbook: boolean;
    name?: string;
    runbookName: string;
    serviceUri?: string;
    useCommonAlertSchema?: boolean;
    webhookResourceId: string;
}

// @public
export interface AutoscaleNotification {
    email?: EmailNotification;
    operation: "Scale";
    webhooks?: WebhookNotification[];
}

// @public
export interface AutoscaleProfile {
    capacity: ScaleCapacity;
    fixedDate?: TimeWindow;
    name: string;
    recurrence?: Recurrence;
    rules: ScaleRule[];
}

// @public
export type AutoscaleSettingResource = Resource & {
    profiles: AutoscaleProfile[];
    notifications?: AutoscaleNotification[];
    enabled?: boolean;
    namePropertiesName?: string;
    targetResourceUri?: string;
    targetResourceLocation?: string;
};

// @public
export interface AutoscaleSettingResourceCollection {
    nextLink?: string;
    value: AutoscaleSettingResource[];
}

// @public
export interface AutoscaleSettingResourcePatch {
    enabled?: boolean;
    name?: string;
    notifications?: AutoscaleNotification[];
    profiles?: AutoscaleProfile[];
    tags?: {
        [propertyName: string]: string;
    };
    targetResourceLocation?: string;
    targetResourceUri?: string;
}

// @public
export interface AutoscaleSettings {
    createOrUpdate(resourceGroupName: string, autoscaleSettingName: string, parameters: AutoscaleSettingResource, options?: AutoscaleSettingsCreateOrUpdateOptionalParams): Promise<AutoscaleSettingsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, autoscaleSettingName: string, options?: AutoscaleSettingsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, autoscaleSettingName: string, options?: AutoscaleSettingsGetOptionalParams): Promise<AutoscaleSettingsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: AutoscaleSettingsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AutoscaleSettingResource>;
    listBySubscription(options?: AutoscaleSettingsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<AutoscaleSettingResource>;
    update(resourceGroupName: string, autoscaleSettingName: string, autoscaleSettingResource: AutoscaleSettingResourcePatch, options?: AutoscaleSettingsUpdateOptionalParams): Promise<AutoscaleSettingsUpdateResponse>;
}

// @public
export interface AutoscaleSettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsCreateOrUpdateResponse = AutoscaleSettingResource;

// @public
export interface AutoscaleSettingsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface AutoscaleSettingsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsGetResponse = AutoscaleSettingResource;

// @public
export interface AutoscaleSettingsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsListByResourceGroupNextResponse = AutoscaleSettingResourceCollection;

// @public
export interface AutoscaleSettingsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsListByResourceGroupResponse = AutoscaleSettingResourceCollection;

// @public
export interface AutoscaleSettingsListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsListBySubscriptionNextResponse = AutoscaleSettingResourceCollection;

// @public
export interface AutoscaleSettingsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsListBySubscriptionResponse = AutoscaleSettingResourceCollection;

// @public
export interface AutoscaleSettingsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AutoscaleSettingsUpdateResponse = AutoscaleSettingResource;

// @public
export interface AzNsActionGroup {
    actionGroup?: string[];
    customWebhookPayload?: string;
    emailSubject?: string;
}

// @public
export interface AzureAppPushReceiver {
    emailAddress: string;
    name: string;
}

// @public
export interface AzureFunctionReceiver {
    functionAppResourceId: string;
    functionName: string;
    httpTriggerUrl: string;
    name: string;
    useCommonAlertSchema?: boolean;
}

// @public
export interface AzureMonitorMetricsDestination {
    name?: string;
}

// @public
export type AzureMonitorPrivateLinkScope = PrivateLinkScopesResource & {
    readonly provisioningState?: string;
    readonly privateEndpointConnections?: PrivateEndpointConnection[];
};

// @public
export interface AzureMonitorPrivateLinkScopeListResult {
    nextLink?: string;
    value: AzureMonitorPrivateLinkScope[];
}

// @public
export interface AzureResource {
    readonly id?: string;
    readonly identity?: string;
    readonly kind?: string;
    location: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface BaselineMetadata {
    name: string;
    value: string;
}

// @public
export interface Baselines {
    list(resourceUri: string, options?: BaselinesListOptionalParams): PagedAsyncIterableIterator<SingleMetricBaseline>;
}

// @public
export type BaselineSensitivity = string;

// @public
export interface BaselinesListOptionalParams extends coreClient.OperationOptions {
    aggregation?: string;
    filter?: string;
    interval?: string;
    metricnames?: string;
    metricnamespace?: string;
    resultType?: ResultType;
    sensitivities?: string;
    timespan?: string;
}

// @public
export type BaselinesListResponse = MetricBaselinesResponse;

// @public
export type CategoryType = "Metrics" | "Logs";

// @public
export type ComparisonOperationType = "Equals" | "NotEquals" | "GreaterThan" | "GreaterThanOrEqual" | "LessThan" | "LessThanOrEqual";

// @public
export type ConditionalOperator = string;

// @public
export type ConditionOperator = "GreaterThan" | "GreaterThanOrEqual" | "LessThan" | "LessThanOrEqual";

// @public
export interface ConfigurationAccessEndpointSpec {
    readonly endpoint?: string;
}

// @public
export interface Context {
    contextType?: string;
    notificationSource?: string;
}

// @public
export type CreatedByType = string;

// @public
export interface Criteria {
    dimensions?: Dimension[];
    metricName: string;
}

// @public
export type CriterionType = string;

// @public
export interface DataCollectionEndpoint {
    configurationAccess?: DataCollectionEndpointConfigurationAccess;
    description?: string;
    immutableId?: string;
    logsIngestion?: DataCollectionEndpointLogsIngestion;
    networkAcls?: DataCollectionEndpointNetworkAcls;
    readonly provisioningState?: KnownDataCollectionEndpointProvisioningState;
}

// @public
export type DataCollectionEndpointConfigurationAccess = ConfigurationAccessEndpointSpec & {};

// @public
export type DataCollectionEndpointLogsIngestion = LogsIngestionEndpointSpec & {};

// @public
export type DataCollectionEndpointNetworkAcls = NetworkRuleSet & {};

// @public
export interface DataCollectionEndpointResource {
    configurationAccess?: DataCollectionEndpointConfigurationAccess;
    description?: string;
    readonly etag?: string;
    readonly id?: string;
    immutableId?: string;
    kind?: KnownDataCollectionEndpointResourceKind;
    location: string;
    logsIngestion?: DataCollectionEndpointLogsIngestion;
    readonly name?: string;
    networkAcls?: DataCollectionEndpointNetworkAcls;
    readonly provisioningState?: KnownDataCollectionEndpointProvisioningState;
    readonly systemData?: DataCollectionEndpointResourceSystemData;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface DataCollectionEndpointResourceListResult {
    nextLink?: string;
    value: DataCollectionEndpointResource[];
}

// @public
export type DataCollectionEndpointResourceProperties = DataCollectionEndpoint & {};

// @public
export type DataCollectionEndpointResourceSystemData = SystemData & {};

// @public
export interface DataCollectionEndpoints {
    create(resourceGroupName: string, dataCollectionEndpointName: string, options?: DataCollectionEndpointsCreateOptionalParams): Promise<DataCollectionEndpointsCreateResponse>;
    delete(resourceGroupName: string, dataCollectionEndpointName: string, options?: DataCollectionEndpointsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, dataCollectionEndpointName: string, options?: DataCollectionEndpointsGetOptionalParams): Promise<DataCollectionEndpointsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: DataCollectionEndpointsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<DataCollectionEndpointResource>;
    listBySubscription(options?: DataCollectionEndpointsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<DataCollectionEndpointResource>;
    update(resourceGroupName: string, dataCollectionEndpointName: string, options?: DataCollectionEndpointsUpdateOptionalParams): Promise<DataCollectionEndpointsUpdateResponse>;
}

// @public
export interface DataCollectionEndpointsCreateOptionalParams extends coreClient.OperationOptions {
    body?: DataCollectionEndpointResource;
}

// @public
export type DataCollectionEndpointsCreateResponse = DataCollectionEndpointResource;

// @public
export interface DataCollectionEndpointsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DataCollectionEndpointsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionEndpointsGetResponse = DataCollectionEndpointResource;

// @public
export interface DataCollectionEndpointsListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionEndpointsListByResourceGroupNextResponse = DataCollectionEndpointResourceListResult;

// @public
export interface DataCollectionEndpointsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionEndpointsListByResourceGroupResponse = DataCollectionEndpointResourceListResult;

// @public
export interface DataCollectionEndpointsListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionEndpointsListBySubscriptionNextResponse = DataCollectionEndpointResourceListResult;

// @public
export interface DataCollectionEndpointsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionEndpointsListBySubscriptionResponse = DataCollectionEndpointResourceListResult;

// @public
export interface DataCollectionEndpointsUpdateOptionalParams extends coreClient.OperationOptions {
    body?: ResourceForUpdate;
}

// @public
export type DataCollectionEndpointsUpdateResponse = DataCollectionEndpointResource;

// @public
export interface DataCollectionRule {
    dataFlows?: DataFlow[];
    dataSources?: DataCollectionRuleDataSources;
    description?: string;
    destinations?: DataCollectionRuleDestinations;
    readonly immutableId?: string;
    readonly provisioningState?: KnownDataCollectionRuleProvisioningState;
}

// @public
export interface DataCollectionRuleAssociation {
    dataCollectionEndpointId?: string;
    dataCollectionRuleId?: string;
    description?: string;
    readonly provisioningState?: KnownDataCollectionRuleAssociationProvisioningState;
}

// @public
export interface DataCollectionRuleAssociationProxyOnlyResource {
    dataCollectionEndpointId?: string;
    dataCollectionRuleId?: string;
    description?: string;
    readonly etag?: string;
    readonly id?: string;
    readonly name?: string;
    readonly provisioningState?: KnownDataCollectionRuleAssociationProvisioningState;
    readonly systemData?: DataCollectionRuleAssociationProxyOnlyResourceSystemData;
    readonly type?: string;
}

// @public
export interface DataCollectionRuleAssociationProxyOnlyResourceListResult {
    nextLink?: string;
    value: DataCollectionRuleAssociationProxyOnlyResource[];
}

// @public
export type DataCollectionRuleAssociationProxyOnlyResourceProperties = DataCollectionRuleAssociation & {};

// @public
export type DataCollectionRuleAssociationProxyOnlyResourceSystemData = SystemData & {};

// @public
export interface DataCollectionRuleAssociations {
    create(resourceUri: string, associationName: string, options?: DataCollectionRuleAssociationsCreateOptionalParams): Promise<DataCollectionRuleAssociationsCreateResponse>;
    delete(resourceUri: string, associationName: string, options?: DataCollectionRuleAssociationsDeleteOptionalParams): Promise<void>;
    get(resourceUri: string, associationName: string, options?: DataCollectionRuleAssociationsGetOptionalParams): Promise<DataCollectionRuleAssociationsGetResponse>;
    listByResource(resourceUri: string, options?: DataCollectionRuleAssociationsListByResourceOptionalParams): PagedAsyncIterableIterator<DataCollectionRuleAssociationProxyOnlyResource>;
    listByRule(resourceGroupName: string, dataCollectionRuleName: string, options?: DataCollectionRuleAssociationsListByRuleOptionalParams): PagedAsyncIterableIterator<DataCollectionRuleAssociationProxyOnlyResource>;
}

// @public
export interface DataCollectionRuleAssociationsCreateOptionalParams extends coreClient.OperationOptions {
    body?: DataCollectionRuleAssociationProxyOnlyResource;
}

// @public
export type DataCollectionRuleAssociationsCreateResponse = DataCollectionRuleAssociationProxyOnlyResource;

// @public
export interface DataCollectionRuleAssociationsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DataCollectionRuleAssociationsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRuleAssociationsGetResponse = DataCollectionRuleAssociationProxyOnlyResource;

// @public
export interface DataCollectionRuleAssociationsListByResourceNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRuleAssociationsListByResourceNextResponse = DataCollectionRuleAssociationProxyOnlyResourceListResult;

// @public
export interface DataCollectionRuleAssociationsListByResourceOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRuleAssociationsListByResourceResponse = DataCollectionRuleAssociationProxyOnlyResourceListResult;

// @public
export interface DataCollectionRuleAssociationsListByRuleNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRuleAssociationsListByRuleNextResponse = DataCollectionRuleAssociationProxyOnlyResourceListResult;

// @public
export interface DataCollectionRuleAssociationsListByRuleOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRuleAssociationsListByRuleResponse = DataCollectionRuleAssociationProxyOnlyResourceListResult;

// @public
export type DataCollectionRuleDataSources = DataSourcesSpec & {};

// @public
export type DataCollectionRuleDestinations = DestinationsSpec & {};

// @public
export interface DataCollectionRuleResource {
    dataFlows?: DataFlow[];
    dataSources?: DataCollectionRuleDataSources;
    description?: string;
    destinations?: DataCollectionRuleDestinations;
    readonly etag?: string;
    readonly id?: string;
    readonly immutableId?: string;
    kind?: KnownDataCollectionRuleResourceKind;
    location: string;
    readonly name?: string;
    readonly provisioningState?: KnownDataCollectionRuleProvisioningState;
    readonly systemData?: DataCollectionRuleResourceSystemData;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface DataCollectionRuleResourceListResult {
    nextLink?: string;
    value: DataCollectionRuleResource[];
}

// @public
export type DataCollectionRuleResourceProperties = DataCollectionRule & {};

// @public
export type DataCollectionRuleResourceSystemData = SystemData & {};

// @public
export interface DataCollectionRules {
    create(resourceGroupName: string, dataCollectionRuleName: string, options?: DataCollectionRulesCreateOptionalParams): Promise<DataCollectionRulesCreateResponse>;
    delete(resourceGroupName: string, dataCollectionRuleName: string, options?: DataCollectionRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, dataCollectionRuleName: string, options?: DataCollectionRulesGetOptionalParams): Promise<DataCollectionRulesGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: DataCollectionRulesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<DataCollectionRuleResource>;
    listBySubscription(options?: DataCollectionRulesListBySubscriptionOptionalParams): PagedAsyncIterableIterator<DataCollectionRuleResource>;
    update(resourceGroupName: string, dataCollectionRuleName: string, options?: DataCollectionRulesUpdateOptionalParams): Promise<DataCollectionRulesUpdateResponse>;
}

// @public
export interface DataCollectionRulesCreateOptionalParams extends coreClient.OperationOptions {
    body?: DataCollectionRuleResource;
}

// @public
export type DataCollectionRulesCreateResponse = DataCollectionRuleResource;

// @public
export interface DataCollectionRulesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DataCollectionRulesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRulesGetResponse = DataCollectionRuleResource;

// @public
export interface DataCollectionRulesListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRulesListByResourceGroupNextResponse = DataCollectionRuleResourceListResult;

// @public
export interface DataCollectionRulesListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRulesListByResourceGroupResponse = DataCollectionRuleResourceListResult;

// @public
export interface DataCollectionRulesListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRulesListBySubscriptionNextResponse = DataCollectionRuleResourceListResult;

// @public
export interface DataCollectionRulesListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DataCollectionRulesListBySubscriptionResponse = DataCollectionRuleResourceListResult;

// @public
export interface DataCollectionRulesUpdateOptionalParams extends coreClient.OperationOptions {
    body?: ResourceForUpdate;
}

// @public
export type DataCollectionRulesUpdateResponse = DataCollectionRuleResource;

// @public
export interface DataContainer {
    workspace: WorkspaceInfo;
}

// @public
export interface DataFlow {
    destinations?: string[];
    streams?: KnownDataFlowStreams[];
}

// @public
export interface DataSourcesSpec {
    extensions?: ExtensionDataSource[];
    performanceCounters?: PerfCounterDataSource[];
    syslog?: SyslogDataSource[];
    windowsEventLogs?: WindowsEventLogDataSource[];
}

// @public
export type DataStatus = string;

// @public
export interface DestinationsSpec {
    azureMonitorMetrics?: DestinationsSpecAzureMonitorMetrics;
    logAnalytics?: LogAnalyticsDestination[];
}

// @public
export type DestinationsSpecAzureMonitorMetrics = AzureMonitorMetricsDestination & {};

// @public
export interface DiagnosticSettings {
    createOrUpdate(resourceUri: string, name: string, parameters: DiagnosticSettingsResource, options?: DiagnosticSettingsCreateOrUpdateOptionalParams): Promise<DiagnosticSettingsCreateOrUpdateResponse>;
    delete(resourceUri: string, name: string, options?: DiagnosticSettingsDeleteOptionalParams): Promise<void>;
    get(resourceUri: string, name: string, options?: DiagnosticSettingsGetOptionalParams): Promise<DiagnosticSettingsGetResponse>;
    list(resourceUri: string, options?: DiagnosticSettingsListOptionalParams): Promise<DiagnosticSettingsListResponse>;
}

// @public
export interface DiagnosticSettingsCategory {
    get(resourceUri: string, name: string, options?: DiagnosticSettingsCategoryGetOptionalParams): Promise<DiagnosticSettingsCategoryGetResponse>;
    list(resourceUri: string, options?: DiagnosticSettingsCategoryListOptionalParams): Promise<DiagnosticSettingsCategoryListResponse>;
}

// @public
export interface DiagnosticSettingsCategoryGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticSettingsCategoryGetResponse = DiagnosticSettingsCategoryResource;

// @public
export interface DiagnosticSettingsCategoryListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticSettingsCategoryListResponse = DiagnosticSettingsCategoryResourceCollection;

// @public
export type DiagnosticSettingsCategoryResource = ProxyOnlyResource & {
    categoryType?: CategoryType;
};

// @public
export interface DiagnosticSettingsCategoryResourceCollection {
    value?: DiagnosticSettingsCategoryResource[];
}

// @public
export interface DiagnosticSettingsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticSettingsCreateOrUpdateResponse = DiagnosticSettingsResource;

// @public
export interface DiagnosticSettingsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface DiagnosticSettingsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticSettingsGetResponse = DiagnosticSettingsResource;

// @public
export interface DiagnosticSettingsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type DiagnosticSettingsListResponse = DiagnosticSettingsResourceCollection;

// @public
export type DiagnosticSettingsResource = ProxyOnlyResource & {
    storageAccountId?: string;
    serviceBusRuleId?: string;
    eventHubAuthorizationRuleId?: string;
    eventHubName?: string;
    metrics?: MetricSettings[];
    logs?: LogSettings[];
    workspaceId?: string;
    logAnalyticsDestinationType?: string;
};

// @public
export interface DiagnosticSettingsResourceCollection {
    value?: DiagnosticSettingsResource[];
}

// @public
export interface Dimension {
    name: string;
    operator: Operator;
    values: string[];
}

// @public
export type DynamicMetricCriteria = MultiMetricCriteria & {
    criterionType: "DynamicThresholdCriterion";
    operator: DynamicThresholdOperator;
    alertSensitivity: DynamicThresholdSensitivity;
    failingPeriods: DynamicThresholdFailingPeriods;
    ignoreDataBefore?: Date;
};

// @public
export interface DynamicThresholdFailingPeriods {
    minFailingPeriodsToAlert: number;
    numberOfEvaluationPeriods: number;
}

// @public
export type DynamicThresholdOperator = string;

// @public
export type DynamicThresholdSensitivity = string;

// @public
export interface EmailNotification {
    customEmails?: string[];
    sendToSubscriptionAdministrator?: boolean;
    sendToSubscriptionCoAdministrators?: boolean;
}

// @public
export interface EmailReceiver {
    emailAddress: string;
    name: string;
    readonly status?: ReceiverStatus;
    useCommonAlertSchema?: boolean;
}

// @public
export type Enabled = string;

// @public
export interface EnableRequest {
    receiverName: string;
}

// @public
export interface ErrorAdditionalInfo {
    readonly info?: Record<string, unknown>;
    readonly type?: string;
}

// @public
export interface ErrorContract {
    error?: ErrorResponse;
}

// @public
export interface ErrorDetail {
    readonly additionalInfo?: ErrorAdditionalInfo[];
    readonly code?: string;
    readonly details?: ErrorDetail[];
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface ErrorModel {
    code: string;
    message?: string;
}

// @public
export interface ErrorResponse {
    code?: string;
    message?: string;
}

// @public
export type ErrorResponseCommon = ErrorResponse & {
    readonly details?: ErrorResponseCommon[];
    readonly additionalInfo?: ErrorAdditionalInfo[];
};

// @public
export interface ErrorResponseCommonV2 {
    error?: ErrorDetail;
}

// @public
export interface EventCategories {
    list(options?: EventCategoriesListOptionalParams): PagedAsyncIterableIterator<LocalizableString>;
}

// @public
export interface EventCategoriesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type EventCategoriesListResponse = EventCategoryCollection;

// @public
export interface EventCategoryCollection {
    value: LocalizableString[];
}

// @public
export interface EventData {
    readonly authorization?: SenderAuthorization;
    readonly caller?: string;
    readonly category?: LocalizableString;
    readonly claims?: {
        [propertyName: string]: string;
    };
    readonly correlationId?: string;
    readonly description?: string;
    readonly eventDataId?: string;
    readonly eventName?: LocalizableString;
    readonly eventTimestamp?: Date;
    readonly httpRequest?: HttpRequestInfo;
    readonly id?: string;
    readonly level?: EventLevel;
    readonly operationId?: string;
    readonly operationName?: LocalizableString;
    readonly properties?: {
        [propertyName: string]: string;
    };
    readonly resourceGroupName?: string;
    readonly resourceId?: string;
    readonly resourceProviderName?: LocalizableString;
    readonly resourceType?: LocalizableString;
    readonly status?: LocalizableString;
    readonly submissionTimestamp?: Date;
    readonly subscriptionId?: string;
    readonly subStatus?: LocalizableString;
    readonly tenantId?: string;
}

// @public
export interface EventDataCollection {
    nextLink?: string;
    value: EventData[];
}

// @public
export interface EventHubReceiver {
    eventHubName: string;
    eventHubNameSpace: string;
    name: string;
    subscriptionId: string;
    tenantId?: string;
    useCommonAlertSchema?: boolean;
}

// @public
export type EventLevel = "Critical" | "Error" | "Warning" | "Informational" | "Verbose";

// @public
export interface ExtensionDataSource {
    extensionName: string;
    extensionSettings?: Record<string, unknown>;
    inputDataSources?: string[];
    name?: string;
    streams?: KnownExtensionDataSourceStreams[];
}

// @public
export interface HttpRequestInfo {
    clientIpAddress?: string;
    clientRequestId?: string;
    method?: string;
    uri?: string;
}

// @public
export interface Incident {
    readonly activatedTime?: Date;
    readonly isActive?: boolean;
    readonly name?: string;
    readonly resolvedTime?: Date;
    readonly ruleName?: string;
}

// @public
export interface IncidentListResult {
    value?: Incident[];
}

// @public
export interface ItsmReceiver {
    connectionId: string;
    name: string;
    region: string;
    ticketConfiguration: string;
    workspaceId: string;
}

// @public
export enum KnownAggregationTypeEnum {
    // (undocumented)
    Average = "Average",
    // (undocumented)
    Count = "Count",
    // (undocumented)
    Maximum = "Maximum",
    // (undocumented)
    Minimum = "Minimum",
    // (undocumented)
    Total = "Total"
}

// @public
export enum KnownAlertSeverity {
    // (undocumented)
    Four = "4",
    // (undocumented)
    One = "1",
    // (undocumented)
    Three = "3",
    // (undocumented)
    Two = "2",
    // (undocumented)
    Zero = "0"
}

// @public
export enum KnownBaselineSensitivity {
    // (undocumented)
    High = "High",
    // (undocumented)
    Low = "Low",
    // (undocumented)
    Medium = "Medium"
}

// @public
export enum KnownConditionalOperator {
    // (undocumented)
    Equal = "Equal",
    // (undocumented)
    GreaterThan = "GreaterThan",
    // (undocumented)
    GreaterThanOrEqual = "GreaterThanOrEqual",
    // (undocumented)
    LessThan = "LessThan",
    // (undocumented)
    LessThanOrEqual = "LessThanOrEqual"
}

// @public
export enum KnownCreatedByType {
    // (undocumented)
    Application = "Application",
    // (undocumented)
    Key = "Key",
    // (undocumented)
    ManagedIdentity = "ManagedIdentity",
    // (undocumented)
    User = "User"
}

// @public
export enum KnownCriterionType {
    // (undocumented)
    DynamicThresholdCriterion = "DynamicThresholdCriterion",
    // (undocumented)
    StaticThresholdCriterion = "StaticThresholdCriterion"
}

// @public
export type KnownDataCollectionEndpointProvisioningState = string;

// @public
export type KnownDataCollectionEndpointResourceKind = string;

// @public
export type KnownDataCollectionRuleAssociationProvisioningState = string;

// @public
export type KnownDataCollectionRuleProvisioningState = string;

// @public
export type KnownDataCollectionRuleResourceKind = string;

// @public
export type KnownDataFlowStreams = string;

// @public
export enum KnownDataStatus {
    // (undocumented)
    NotPresent = "notPresent",
    // (undocumented)
    Present = "present"
}

// @public
export enum KnownDynamicThresholdOperator {
    // (undocumented)
    GreaterOrLessThan = "GreaterOrLessThan",
    // (undocumented)
    GreaterThan = "GreaterThan",
    // (undocumented)
    LessThan = "LessThan"
}

// @public
export enum KnownDynamicThresholdSensitivity {
    // (undocumented)
    High = "High",
    // (undocumented)
    Low = "Low",
    // (undocumented)
    Medium = "Medium"
}

// @public
export enum KnownEnabled {
    // (undocumented)
    False = "false",
    // (undocumented)
    True = "true"
}

// @public
export type KnownExtensionDataSourceStreams = string;

// @public
export enum KnownKnownDataCollectionEndpointProvisioningState {
    // (undocumented)
    Creating = "Creating",
    // (undocumented)
    Deleting = "Deleting",
    // (undocumented)
    Failed = "Failed",
    // (undocumented)
    Succeeded = "Succeeded",
    // (undocumented)
    Updating = "Updating"
}

// @public
export enum KnownKnownDataCollectionEndpointResourceKind {
    // (undocumented)
    Linux = "Linux",
    // (undocumented)
    Windows = "Windows"
}

// @public
export enum KnownKnownDataCollectionRuleAssociationProvisioningState {
    // (undocumented)
    Creating = "Creating",
    // (undocumented)
    Deleting = "Deleting",
    // (undocumented)
    Failed = "Failed",
    // (undocumented)
    Succeeded = "Succeeded",
    // (undocumented)
    Updating = "Updating"
}

// @public
export enum KnownKnownDataCollectionRuleProvisioningState {
    // (undocumented)
    Creating = "Creating",
    // (undocumented)
    Deleting = "Deleting",
    // (undocumented)
    Failed = "Failed",
    // (undocumented)
    Succeeded = "Succeeded",
    // (undocumented)
    Updating = "Updating"
}

// @public
export enum KnownKnownDataCollectionRuleResourceKind {
    // (undocumented)
    Linux = "Linux",
    // (undocumented)
    Windows = "Windows"
}

// @public
export enum KnownKnownDataFlowStreams {
    // (undocumented)
    MicrosoftEvent = "Microsoft-Event",
    // (undocumented)
    MicrosoftInsightsMetrics = "Microsoft-InsightsMetrics",
    // (undocumented)
    MicrosoftPerf = "Microsoft-Perf",
    // (undocumented)
    MicrosoftSyslog = "Microsoft-Syslog",
    // (undocumented)
    MicrosoftWindowsEvent = "Microsoft-WindowsEvent"
}

// @public
export enum KnownKnownExtensionDataSourceStreams {
    // (undocumented)
    MicrosoftEvent = "Microsoft-Event",
    // (undocumented)
    MicrosoftInsightsMetrics = "Microsoft-InsightsMetrics",
    // (undocumented)
    MicrosoftPerf = "Microsoft-Perf",
    // (undocumented)
    MicrosoftSyslog = "Microsoft-Syslog",
    // (undocumented)
    MicrosoftWindowsEvent = "Microsoft-WindowsEvent"
}

// @public
export enum KnownKnownPerfCounterDataSourceStreams {
    // (undocumented)
    MicrosoftInsightsMetrics = "Microsoft-InsightsMetrics",
    // (undocumented)
    MicrosoftPerf = "Microsoft-Perf"
}

// @public
export enum KnownKnownPublicNetworkAccessOptions {
    // (undocumented)
    Disabled = "Disabled",
    // (undocumented)
    Enabled = "Enabled"
}

// @public
export enum KnownKnownSyslogDataSourceFacilityNames {
    // (undocumented)
    Asterisk = "*",
    // (undocumented)
    Auth = "auth",
    // (undocumented)
    Authpriv = "authpriv",
    // (undocumented)
    Cron = "cron",
    // (undocumented)
    Daemon = "daemon",
    // (undocumented)
    Kern = "kern",
    // (undocumented)
    Local0 = "local0",
    // (undocumented)
    Local1 = "local1",
    // (undocumented)
    Local2 = "local2",
    // (undocumented)
    Local3 = "local3",
    // (undocumented)
    Local4 = "local4",
    // (undocumented)
    Local5 = "local5",
    // (undocumented)
    Local6 = "local6",
    // (undocumented)
    Local7 = "local7",
    // (undocumented)
    Lpr = "lpr",
    // (undocumented)
    Mail = "mail",
    // (undocumented)
    Mark = "mark",
    // (undocumented)
    News = "news",
    // (undocumented)
    Syslog = "syslog",
    // (undocumented)
    User = "user",
    // (undocumented)
    Uucp = "uucp"
}

// @public
export enum KnownKnownSyslogDataSourceLogLevels {
    // (undocumented)
    Alert = "Alert",
    // (undocumented)
    Asterisk = "*",
    // (undocumented)
    Critical = "Critical",
    // (undocumented)
    Debug = "Debug",
    // (undocumented)
    Emergency = "Emergency",
    // (undocumented)
    Error = "Error",
    // (undocumented)
    Info = "Info",
    // (undocumented)
    Notice = "Notice",
    // (undocumented)
    Warning = "Warning"
}

// @public
export enum KnownKnownSyslogDataSourceStreams {
    // (undocumented)
    MicrosoftSyslog = "Microsoft-Syslog"
}

// @public
export enum KnownKnownWindowsEventLogDataSourceStreams {
    // (undocumented)
    MicrosoftEvent = "Microsoft-Event",
    // (undocumented)
    MicrosoftWindowsEvent = "Microsoft-WindowsEvent"
}

// @public
export enum KnownMetricClass {
    // (undocumented)
    Availability = "Availability",
    // (undocumented)
    Errors = "Errors",
    // (undocumented)
    Latency = "Latency",
    // (undocumented)
    Saturation = "Saturation",
    // (undocumented)
    Transactions = "Transactions"
}

// @public
export enum KnownMetricTriggerType {
    // (undocumented)
    Consecutive = "Consecutive",
    // (undocumented)
    Total = "Total"
}

// @public
export enum KnownMetricUnit {
    // (undocumented)
    BitsPerSecond = "BitsPerSecond",
    // (undocumented)
    Bytes = "Bytes",
    // (undocumented)
    ByteSeconds = "ByteSeconds",
    // (undocumented)
    BytesPerSecond = "BytesPerSecond",
    // (undocumented)
    Cores = "Cores",
    // (undocumented)
    Count = "Count",
    // (undocumented)
    CountPerSecond = "CountPerSecond",
    // (undocumented)
    MilliCores = "MilliCores",
    // (undocumented)
    MilliSeconds = "MilliSeconds",
    // (undocumented)
    NanoCores = "NanoCores",
    // (undocumented)
    Percent = "Percent",
    // (undocumented)
    Seconds = "Seconds",
    // (undocumented)
    Unspecified = "Unspecified"
}

// @public
export enum KnownNamespaceClassification {
    // (undocumented)
    Custom = "Custom",
    // (undocumented)
    Platform = "Platform",
    // (undocumented)
    Qos = "Qos"
}

// @public
export enum KnownOdatatype {
    // (undocumented)
    MicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria = "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
    // (undocumented)
    MicrosoftAzureMonitorSingleResourceMultipleMetricCriteria = "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria",
    // (undocumented)
    MicrosoftAzureMonitorWebtestLocationAvailabilityCriteria = "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria"
}

// @public
export enum KnownOnboardingStatus {
    // (undocumented)
    NotOnboarded = "notOnboarded",
    // (undocumented)
    Onboarded = "onboarded",
    // (undocumented)
    Unknown = "unknown"
}

// @public
export enum KnownOperator {
    // (undocumented)
    Equals = "Equals",
    // (undocumented)
    GreaterThan = "GreaterThan",
    // (undocumented)
    GreaterThanOrEqual = "GreaterThanOrEqual",
    // (undocumented)
    Include = "Include",
    // (undocumented)
    LessThan = "LessThan",
    // (undocumented)
    LessThanOrEqual = "LessThanOrEqual"
}

// @public
export type KnownPerfCounterDataSourceStreams = string;

// @public
export enum KnownProvisioningState {
    // (undocumented)
    Canceled = "Canceled",
    // (undocumented)
    Deploying = "Deploying",
    // (undocumented)
    Failed = "Failed",
    // (undocumented)
    Succeeded = "Succeeded"
}

// @public
export type KnownPublicNetworkAccessOptions = string;

// @public
export enum KnownQueryType {
    // (undocumented)
    ResultCount = "ResultCount"
}

// @public
export enum KnownScaleRuleMetricDimensionOperationType {
    // (undocumented)
    Equals = "Equals",
    // (undocumented)
    NotEquals = "NotEquals"
}

// @public
export type KnownSyslogDataSourceFacilityNames = string;

// @public
export type KnownSyslogDataSourceLogLevels = string;

// @public
export type KnownSyslogDataSourceStreams = string;

// @public
export type KnownWindowsEventLogDataSourceStreams = string;

// @public
export interface LocalizableString {
    localizedValue?: string;
    value: string;
}

// @public
export type LocationThresholdRuleCondition = RuleCondition & {
    odataType: "Microsoft.Azure.Management.Insights.Models.LocationThresholdRuleCondition";
    windowSize?: string;
    failedLocationCount: number;
};

// @public
export interface LogAnalyticsDestination {
    name?: string;
    readonly workspaceId?: string;
    workspaceResourceId?: string;
}

// @public
export interface LogicAppReceiver {
    callbackUrl: string;
    name: string;
    resourceId: string;
    useCommonAlertSchema?: boolean;
}

// @public
export interface LogMetricTrigger {
    metricColumn?: string;
    metricTriggerType?: MetricTriggerType;
    threshold?: number;
    thresholdOperator?: ConditionalOperator;
}

// @public
export interface LogProfileCollection {
    value: LogProfileResource[];
}

// @public
export type LogProfileResource = Resource & {
    storageAccountId?: string;
    serviceBusRuleId?: string;
    locations: string[];
    categories: string[];
    retentionPolicy: RetentionPolicy;
};

// @public
export interface LogProfileResourcePatch {
    categories?: string[];
    locations?: string[];
    retentionPolicy?: RetentionPolicy;
    serviceBusRuleId?: string;
    storageAccountId?: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface LogProfiles {
    createOrUpdate(logProfileName: string, parameters: LogProfileResource, options?: LogProfilesCreateOrUpdateOptionalParams): Promise<LogProfilesCreateOrUpdateResponse>;
    delete(logProfileName: string, options?: LogProfilesDeleteOptionalParams): Promise<void>;
    get(logProfileName: string, options?: LogProfilesGetOptionalParams): Promise<LogProfilesGetResponse>;
    list(options?: LogProfilesListOptionalParams): PagedAsyncIterableIterator<LogProfileResource>;
    update(logProfileName: string, logProfilesResource: LogProfileResourcePatch, options?: LogProfilesUpdateOptionalParams): Promise<LogProfilesUpdateResponse>;
}

// @public
export interface LogProfilesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LogProfilesCreateOrUpdateResponse = LogProfileResource;

// @public
export interface LogProfilesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface LogProfilesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LogProfilesGetResponse = LogProfileResource;

// @public
export interface LogProfilesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LogProfilesListResponse = LogProfileCollection;

// @public
export interface LogProfilesUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LogProfilesUpdateResponse = LogProfileResource;

// @public
export type LogSearchRuleResource = ResourceAutoGenerated & {
    readonly createdWithApiVersion?: string;
    readonly isLegacyLogAnalyticsRule?: boolean;
    description?: string;
    displayName?: string;
    autoMitigate?: boolean;
    enabled?: Enabled;
    readonly lastUpdatedTime?: Date;
    readonly provisioningState?: ProvisioningState;
    source: Source;
    schedule?: Schedule;
    action: ActionUnion;
};

// @public
export interface LogSearchRuleResourceCollection {
    value?: LogSearchRuleResource[];
}

// @public
export interface LogSearchRuleResourcePatch {
    enabled?: Enabled;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface LogSettings {
    category?: string;
    enabled: boolean;
    retentionPolicy?: RetentionPolicy;
}

// @public
export interface LogsIngestionEndpointSpec {
    readonly endpoint?: string;
}

// @public
export type LogToMetricAction = Action & {
    odataType: "Microsoft.WindowsAzure.Management.Monitoring.Alerts.Models.Microsoft.AppInsights.Nexus.DataContracts.Resources.ScheduledQueryRules.LogToMetricAction";
    criteria: Criteria[];
};

// @public
export interface ManagementEventAggregationCondition {
    operator?: ConditionOperator;
    threshold?: number;
    windowSize?: string;
}

// @public
export type ManagementEventRuleCondition = RuleCondition & {
    odataType: "Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition";
    aggregation?: ManagementEventAggregationCondition;
};

// @public
export interface MetadataValue {
    name?: LocalizableString;
    value?: string;
}

// @public
export interface Metric {
    displayDescription?: string;
    errorCode?: string;
    errorMessage?: string;
    id: string;
    name: LocalizableString;
    timeseries: TimeSeriesElement[];
    type: string;
    unit: MetricUnit;
}

// @public
export interface MetricAlertAction {
    actionGroupId?: string;
    webHookProperties?: {
        [propertyName: string]: string;
    };
}

// @public
export interface MetricAlertCriteria {
    [property: string]: any;
    odataType: "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria" | "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria" | "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria";
}

// @public (undocumented)
export type MetricAlertCriteriaUnion = MetricAlertCriteria | MetricAlertSingleResourceMultipleMetricCriteria | WebtestLocationAvailabilityCriteria | MetricAlertMultipleResourceMultipleMetricCriteria;

// @public
export type MetricAlertMultipleResourceMultipleMetricCriteria = MetricAlertCriteria & {
    odataType: "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria";
    allOf?: MultiMetricCriteriaUnion[];
};

// @public
export type MetricAlertResource = Resource & {
    description?: string;
    severity: number;
    enabled: boolean;
    scopes: string[];
    evaluationFrequency: string;
    windowSize: string;
    targetResourceType?: string;
    targetResourceRegion?: string;
    criteria: MetricAlertCriteriaUnion;
    autoMitigate?: boolean;
    actions?: MetricAlertAction[];
    readonly lastUpdatedTime?: Date;
    readonly isMigrated?: boolean;
};

// @public
export interface MetricAlertResourceCollection {
    value?: MetricAlertResource[];
}

// @public
export interface MetricAlertResourcePatch {
    actions?: MetricAlertAction[];
    autoMitigate?: boolean;
    criteria?: MetricAlertCriteriaUnion;
    description?: string;
    enabled?: boolean;
    evaluationFrequency?: string;
    readonly isMigrated?: boolean;
    readonly lastUpdatedTime?: Date;
    scopes?: string[];
    severity?: number;
    tags?: {
        [propertyName: string]: string;
    };
    targetResourceRegion?: string;
    targetResourceType?: string;
    windowSize?: string;
}

// @public
export interface MetricAlerts {
    createOrUpdate(resourceGroupName: string, ruleName: string, parameters: MetricAlertResource, options?: MetricAlertsCreateOrUpdateOptionalParams): Promise<MetricAlertsCreateOrUpdateResponse>;
    delete(resourceGroupName: string, ruleName: string, options?: MetricAlertsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ruleName: string, options?: MetricAlertsGetOptionalParams): Promise<MetricAlertsGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: MetricAlertsListByResourceGroupOptionalParams): PagedAsyncIterableIterator<MetricAlertResource>;
    listBySubscription(options?: MetricAlertsListBySubscriptionOptionalParams): PagedAsyncIterableIterator<MetricAlertResource>;
    update(resourceGroupName: string, ruleName: string, parameters: MetricAlertResourcePatch, options?: MetricAlertsUpdateOptionalParams): Promise<MetricAlertsUpdateResponse>;
}

// @public
export interface MetricAlertsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsCreateOrUpdateResponse = MetricAlertResource;

// @public
export interface MetricAlertsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface MetricAlertsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsGetResponse = MetricAlertResource;

// @public
export type MetricAlertSingleResourceMultipleMetricCriteria = MetricAlertCriteria & {
    odataType: "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria";
    allOf?: MetricCriteria[];
};

// @public
export interface MetricAlertsListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsListByResourceGroupResponse = MetricAlertResourceCollection;

// @public
export interface MetricAlertsListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsListBySubscriptionResponse = MetricAlertResourceCollection;

// @public
export interface MetricAlertsStatus {
    list(resourceGroupName: string, ruleName: string, options?: MetricAlertsStatusListOptionalParams): Promise<MetricAlertsStatusListResponse>;
    listByName(resourceGroupName: string, ruleName: string, statusName: string, options?: MetricAlertsStatusListByNameOptionalParams): Promise<MetricAlertsStatusListByNameResponse>;
}

// @public
export interface MetricAlertsStatusListByNameOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsStatusListByNameResponse = MetricAlertStatusCollection;

// @public
export interface MetricAlertsStatusListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsStatusListResponse = MetricAlertStatusCollection;

// @public
export interface MetricAlertStatus {
    id?: string;
    name?: string;
    properties?: MetricAlertStatusProperties;
    type?: string;
}

// @public
export interface MetricAlertStatusCollection {
    value?: MetricAlertStatus[];
}

// @public
export interface MetricAlertStatusProperties {
    dimensions?: {
        [propertyName: string]: string;
    };
    status?: string;
    timestamp?: Date;
}

// @public
export interface MetricAlertsUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type MetricAlertsUpdateResponse = MetricAlertResource;

// @public
export interface MetricAvailability {
    retention?: string;
    timeGrain?: string;
}

// @public
export interface MetricBaselinesResponse {
    value?: SingleMetricBaseline[];
}

// @public
export type MetricClass = string;

// @public
export type MetricCriteria = MultiMetricCriteria & {
    criterionType: "StaticThresholdCriterion";
    operator: Operator;
    threshold: number;
};

// @public
export interface MetricDefinition {
    category?: string;
    dimensions?: LocalizableString[];
    displayDescription?: string;
    id?: string;
    isDimensionRequired?: boolean;
    metricAvailabilities?: MetricAvailability[];
    metricClass?: MetricClass;
    name?: LocalizableString;
    namespace?: string;
    primaryAggregationType?: AggregationType;
    resourceId?: string;
    supportedAggregationTypes?: AggregationType[];
    unit?: MetricUnit;
}

// @public
export interface MetricDefinitionCollection {
    value: MetricDefinition[];
}

// @public
export interface MetricDefinitions {
    list(resourceUri: string, options?: MetricDefinitionsListOptionalParams): PagedAsyncIterableIterator<MetricDefinition>;
}

// @public
export interface MetricDefinitionsListOptionalParams extends coreClient.OperationOptions {
    metricnamespace?: string;
}

// @public
export type MetricDefinitionsListResponse = MetricDefinitionCollection;

// @public
export interface MetricDimension {
    name: string;
    operator: string;
    values: string[];
}

// @public
export interface MetricNamespace {
    classification?: NamespaceClassification;
    id?: string;
    name?: string;
    properties?: MetricNamespaceName;
    type?: string;
}

// @public
export interface MetricNamespaceCollection {
    value: MetricNamespace[];
}

// @public
export interface MetricNamespaceName {
    metricNamespaceName?: string;
}

// @public
export interface MetricNamespaces {
    list(resourceUri: string, options?: MetricNamespacesListOptionalParams): PagedAsyncIterableIterator<MetricNamespace>;
}

// @public
export interface MetricNamespacesListOptionalParams extends coreClient.OperationOptions {
    startTime?: string;
}

// @public
export type MetricNamespacesListResponse = MetricNamespaceCollection;

// @public
export interface Metrics {
    list(resourceUri: string, options?: MetricsListOptionalParams): Promise<MetricsListResponse>;
}

// @public
export interface MetricSettings {
    category?: string;
    enabled: boolean;
    retentionPolicy?: RetentionPolicy;
    timeGrain?: string;
}

// @public
export interface MetricSingleDimension {
    name: string;
    value: string;
}

// @public
export interface MetricsListOptionalParams extends coreClient.OperationOptions {
    aggregation?: string;
    filter?: string;
    interval?: string;
    metricnames?: string;
    metricnamespace?: string;
    orderby?: string;
    resultType?: ResultType;
    timespan?: string;
    top?: number;
}

// @public
export type MetricsListResponse = Response_2;

// @public
export type MetricStatisticType = "Average" | "Min" | "Max" | "Sum" | "Count";

// @public
export interface MetricTrigger {
    dimensions?: ScaleRuleMetricDimension[];
    dividePerInstance?: boolean;
    metricName: string;
    metricNamespace?: string;
    metricResourceLocation?: string;
    metricResourceUri: string;
    operator: ComparisonOperationType;
    statistic: MetricStatisticType;
    threshold: number;
    timeAggregation: TimeAggregationType;
    timeGrain: string;
    timeWindow: string;
}

// @public
export type MetricTriggerType = string;

// @public
export type MetricUnit = string;

// @public
export interface MetricValue {
    average?: number;
    count?: number;
    maximum?: number;
    minimum?: number;
    timeStamp: Date;
    total?: number;
}

// @public (undocumented)
export class MonitorClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: MonitorClientOptionalParams);
    // (undocumented)
    actionGroups: ActionGroups;
    // (undocumented)
    activityLogAlerts: ActivityLogAlerts;
    // (undocumented)
    activityLogs: ActivityLogs;
    // (undocumented)
    alertRuleIncidents: AlertRuleIncidents;
    // (undocumented)
    alertRules: AlertRules;
    // (undocumented)
    autoscaleSettings: AutoscaleSettings;
    // (undocumented)
    baselines: Baselines;
    // (undocumented)
    dataCollectionEndpoints: DataCollectionEndpoints;
    // (undocumented)
    dataCollectionRuleAssociations: DataCollectionRuleAssociations;
    // (undocumented)
    dataCollectionRules: DataCollectionRules;
    // (undocumented)
    diagnosticSettings: DiagnosticSettings;
    // (undocumented)
    diagnosticSettingsCategory: DiagnosticSettingsCategory;
    // (undocumented)
    eventCategories: EventCategories;
    // (undocumented)
    logProfiles: LogProfiles;
    // (undocumented)
    metricAlerts: MetricAlerts;
    // (undocumented)
    metricAlertsStatus: MetricAlertsStatus;
    // (undocumented)
    metricDefinitions: MetricDefinitions;
    // (undocumented)
    metricNamespaces: MetricNamespaces;
    // (undocumented)
    metrics: Metrics;
    // (undocumented)
    operations: Operations;
    // (undocumented)
    privateEndpointConnections: PrivateEndpointConnections;
    // (undocumented)
    privateLinkResources: PrivateLinkResources;
    // (undocumented)
    privateLinkScopedResources: PrivateLinkScopedResources;
    // (undocumented)
    privateLinkScopeOperationStatus: PrivateLinkScopeOperationStatus;
    // (undocumented)
    privateLinkScopes: PrivateLinkScopes;
    // (undocumented)
    scheduledQueryRules: ScheduledQueryRules;
    // (undocumented)
    subscriptionId: string;
    // (undocumented)
    tenantActivityLogs: TenantActivityLogs;
    // (undocumented)
    vMInsights: VMInsights;
}

// @public
export interface MonitorClientOptionalParams extends coreClient.ServiceClientOptions {
    $host?: string;
    endpoint?: string;
}

// @public
export interface MultiMetricCriteria {
    [property: string]: any;
    criterionType: "StaticThresholdCriterion" | "DynamicThresholdCriterion";
    dimensions?: MetricDimension[];
    metricName: string;
    metricNamespace?: string;
    name: string;
    skipMetricValidation?: boolean;
    timeAggregation: AggregationTypeEnum;
}

// @public (undocumented)
export type MultiMetricCriteriaUnion = MultiMetricCriteria | MetricCriteria | DynamicMetricCriteria;

// @public
export type NamespaceClassification = string;

// @public
export interface NetworkRuleSet {
    publicNetworkAccess?: KnownPublicNetworkAccessOptions;
}

// @public
export interface NotificationRequestBody {
    alertType: string;
    armRoleReceivers?: ArmRoleReceiver[];
    automationRunbookReceivers?: AutomationRunbookReceiver[];
    azureAppPushReceivers?: AzureAppPushReceiver[];
    azureFunctionReceivers?: AzureFunctionReceiver[];
    emailReceivers?: EmailReceiver[];
    eventHubReceivers?: EventHubReceiver[];
    itsmReceivers?: ItsmReceiver[];
    logicAppReceivers?: LogicAppReceiver[];
    smsReceivers?: SmsReceiver[];
    voiceReceivers?: VoiceReceiver[];
    webhookReceivers?: WebhookReceiver[];
}

// @public
export type Odatatype = string;

// @public
export type OnboardingStatus = string;

// @public
export interface Operation {
    display?: OperationDisplay;
    name?: string;
}

// @public
export interface OperationDisplay {
    operation?: string;
    provider?: string;
    resource?: string;
}

// @public
export interface OperationListResult {
    nextLink?: string;
    value?: Operation[];
}

// @public
export interface Operations {
    list(options?: OperationsListOptionalParams): Promise<OperationsListResponse>;
}

// @public
export interface OperationsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type OperationsListResponse = OperationListResult;

// @public
export interface OperationStatus {
    endTime?: Date;
    error?: ErrorResponseCommon;
    id?: string;
    name?: string;
    startTime?: Date;
    status?: string;
}

// @public
export type Operator = string;

// @public
export interface PerfCounterDataSource {
    counterSpecifiers?: string[];
    name?: string;
    samplingFrequencyInSeconds?: number;
    streams?: KnownPerfCounterDataSourceStreams[];
}

// @public
export type PrivateEndpointConnection = ProxyResource & {
    privateEndpoint?: PrivateEndpointProperty;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionStateProperty;
    readonly provisioningState?: string;
};

// @public
export interface PrivateEndpointConnectionListResult {
    readonly nextLink?: string;
    readonly value?: PrivateEndpointConnection[];
}

// @public
export interface PrivateEndpointConnections {
    beginCreateOrUpdate(resourceGroupName: string, scopeName: string, privateEndpointConnectionName: string, parameters: PrivateEndpointConnection, options?: PrivateEndpointConnectionsCreateOrUpdateOptionalParams): Promise<PollerLike<PollOperationState<PrivateEndpointConnectionsCreateOrUpdateResponse>, PrivateEndpointConnectionsCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, scopeName: string, privateEndpointConnectionName: string, parameters: PrivateEndpointConnection, options?: PrivateEndpointConnectionsCreateOrUpdateOptionalParams): Promise<PrivateEndpointConnectionsCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, scopeName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionsDeleteOptionalParams): Promise<PollerLike<PollOperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, scopeName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, scopeName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionsGetOptionalParams): Promise<PrivateEndpointConnectionsGetResponse>;
    listByPrivateLinkScope(resourceGroupName: string, scopeName: string, options?: PrivateEndpointConnectionsListByPrivateLinkScopeOptionalParams): PagedAsyncIterableIterator<PrivateEndpointConnection>;
}

// @public
export interface PrivateEndpointConnectionsCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PrivateEndpointConnectionsCreateOrUpdateResponse = PrivateEndpointConnection;

// @public
export interface PrivateEndpointConnectionsDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface PrivateEndpointConnectionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateEndpointConnectionsGetResponse = PrivateEndpointConnection;

// @public
export interface PrivateEndpointConnectionsListByPrivateLinkScopeNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateEndpointConnectionsListByPrivateLinkScopeNextResponse = PrivateEndpointConnectionListResult;

// @public
export interface PrivateEndpointConnectionsListByPrivateLinkScopeOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateEndpointConnectionsListByPrivateLinkScopeResponse = PrivateEndpointConnectionListResult;

// @public
export interface PrivateEndpointProperty {
    id?: string;
}

// @public
export type PrivateLinkResource = ProxyResource & {
    readonly groupId?: string;
    readonly requiredMembers?: string[];
};

// @public
export interface PrivateLinkResourceListResult {
    readonly nextLink?: string;
    readonly value?: PrivateLinkResource[];
}

// @public
export interface PrivateLinkResources {
    get(resourceGroupName: string, scopeName: string, groupName: string, options?: PrivateLinkResourcesGetOptionalParams): Promise<PrivateLinkResourcesGetResponse>;
    listByPrivateLinkScope(resourceGroupName: string, scopeName: string, options?: PrivateLinkResourcesListByPrivateLinkScopeOptionalParams): PagedAsyncIterableIterator<PrivateLinkResource>;
}

// @public
export interface PrivateLinkResourcesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkResourcesGetResponse = PrivateLinkResource;

// @public
export interface PrivateLinkResourcesListByPrivateLinkScopeNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkResourcesListByPrivateLinkScopeNextResponse = PrivateLinkResourceListResult;

// @public
export interface PrivateLinkResourcesListByPrivateLinkScopeOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkResourcesListByPrivateLinkScopeResponse = PrivateLinkResourceListResult;

// @public
export interface PrivateLinkScopedResources {
    beginCreateOrUpdate(resourceGroupName: string, scopeName: string, name: string, parameters: ScopedResource, options?: PrivateLinkScopedResourcesCreateOrUpdateOptionalParams): Promise<PollerLike<PollOperationState<PrivateLinkScopedResourcesCreateOrUpdateResponse>, PrivateLinkScopedResourcesCreateOrUpdateResponse>>;
    beginCreateOrUpdateAndWait(resourceGroupName: string, scopeName: string, name: string, parameters: ScopedResource, options?: PrivateLinkScopedResourcesCreateOrUpdateOptionalParams): Promise<PrivateLinkScopedResourcesCreateOrUpdateResponse>;
    beginDelete(resourceGroupName: string, scopeName: string, name: string, options?: PrivateLinkScopedResourcesDeleteOptionalParams): Promise<PollerLike<PollOperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, scopeName: string, name: string, options?: PrivateLinkScopedResourcesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, scopeName: string, name: string, options?: PrivateLinkScopedResourcesGetOptionalParams): Promise<PrivateLinkScopedResourcesGetResponse>;
    listByPrivateLinkScope(resourceGroupName: string, scopeName: string, options?: PrivateLinkScopedResourcesListByPrivateLinkScopeOptionalParams): PagedAsyncIterableIterator<ScopedResource>;
}

// @public
export interface PrivateLinkScopedResourcesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PrivateLinkScopedResourcesCreateOrUpdateResponse = ScopedResource;

// @public
export interface PrivateLinkScopedResourcesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface PrivateLinkScopedResourcesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopedResourcesGetResponse = ScopedResource;

// @public
export interface PrivateLinkScopedResourcesListByPrivateLinkScopeNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopedResourcesListByPrivateLinkScopeNextResponse = ScopedResourceListResult;

// @public
export interface PrivateLinkScopedResourcesListByPrivateLinkScopeOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopedResourcesListByPrivateLinkScopeResponse = ScopedResourceListResult;

// @public
export interface PrivateLinkScopeOperationStatus {
    get(asyncOperationId: string, resourceGroupName: string, options?: PrivateLinkScopeOperationStatusGetOptionalParams): Promise<PrivateLinkScopeOperationStatusGetResponse>;
}

// @public
export interface PrivateLinkScopeOperationStatusGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopeOperationStatusGetResponse = OperationStatus;

// @public
export interface PrivateLinkScopes {
    beginDelete(resourceGroupName: string, scopeName: string, options?: PrivateLinkScopesDeleteOptionalParams): Promise<PollerLike<PollOperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, scopeName: string, options?: PrivateLinkScopesDeleteOptionalParams): Promise<void>;
    createOrUpdate(resourceGroupName: string, scopeName: string, azureMonitorPrivateLinkScopePayload: AzureMonitorPrivateLinkScope, options?: PrivateLinkScopesCreateOrUpdateOptionalParams): Promise<PrivateLinkScopesCreateOrUpdateResponse>;
    get(resourceGroupName: string, scopeName: string, options?: PrivateLinkScopesGetOptionalParams): Promise<PrivateLinkScopesGetResponse>;
    list(options?: PrivateLinkScopesListOptionalParams): PagedAsyncIterableIterator<AzureMonitorPrivateLinkScope>;
    listByResourceGroup(resourceGroupName: string, options?: PrivateLinkScopesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<AzureMonitorPrivateLinkScope>;
    updateTags(resourceGroupName: string, scopeName: string, privateLinkScopeTags: TagsResource, options?: PrivateLinkScopesUpdateTagsOptionalParams): Promise<PrivateLinkScopesUpdateTagsResponse>;
}

// @public
export interface PrivateLinkScopesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesCreateOrUpdateResponse = AzureMonitorPrivateLinkScope;

// @public
export interface PrivateLinkScopesDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface PrivateLinkScopesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesGetResponse = AzureMonitorPrivateLinkScope;

// @public
export interface PrivateLinkScopesListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesListByResourceGroupNextResponse = AzureMonitorPrivateLinkScopeListResult;

// @public
export interface PrivateLinkScopesListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesListByResourceGroupResponse = AzureMonitorPrivateLinkScopeListResult;

// @public
export interface PrivateLinkScopesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesListNextResponse = AzureMonitorPrivateLinkScopeListResult;

// @public
export interface PrivateLinkScopesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesListResponse = AzureMonitorPrivateLinkScopeListResult;

// @public
export interface PrivateLinkScopesResource {
    readonly id?: string;
    location: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface PrivateLinkScopesUpdateTagsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkScopesUpdateTagsResponse = AzureMonitorPrivateLinkScope;

// @public
export interface PrivateLinkServiceConnectionStateProperty {
    readonly actionsRequired?: string;
    description: string;
    status: string;
}

// @public
export type ProvisioningState = string;

// @public
export interface ProxyOnlyResource {
    readonly id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export interface ProxyResource {
    readonly id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export type QueryType = string;

// @public
export type ReceiverStatus = "NotSpecified" | "Enabled" | "Disabled";

// @public
export interface Recurrence {
    frequency: RecurrenceFrequency;
    schedule: RecurrentSchedule;
}

// @public
export type RecurrenceFrequency = "None" | "Second" | "Minute" | "Hour" | "Day" | "Week" | "Month" | "Year";

// @public
export interface RecurrentSchedule {
    days: string[];
    hours: number[];
    minutes: number[];
    timeZone: string;
}

// @public
export interface Resource {
    readonly id?: string;
    location: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface ResourceAutoGenerated {
    readonly etag?: string;
    readonly id?: string;
    readonly kind?: string;
    location: string;
    readonly name?: string;
    tags?: {
        [propertyName: string]: string;
    };
    readonly type?: string;
}

// @public
export interface ResourceForUpdate {
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
interface Response_2 {
    cost?: number;
    interval?: string;
    namespace?: string;
    resourceregion?: string;
    timespan: string;
    value: Metric[];
}
export { Response_2 as Response }

// @public
export interface ResponseWithError {
    error: ErrorModel;
}

// @public
export type ResultType = "Data" | "Metadata";

// @public
export interface RetentionPolicy {
    days: number;
    enabled: boolean;
}

// @public
export interface RuleAction {
    odataType: "Microsoft.Azure.Management.Insights.Models.RuleEmailAction" | "Microsoft.Azure.Management.Insights.Models.RuleWebhookAction";
}

// @public (undocumented)
export type RuleActionUnion = RuleAction | RuleEmailAction | RuleWebhookAction;

// @public
export interface RuleCondition {
    dataSource?: RuleDataSourceUnion;
    odataType: "Microsoft.Azure.Management.Insights.Models.ThresholdRuleCondition" | "Microsoft.Azure.Management.Insights.Models.LocationThresholdRuleCondition" | "Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition";
}

// @public (undocumented)
export type RuleConditionUnion = RuleCondition | ThresholdRuleCondition | LocationThresholdRuleCondition | ManagementEventRuleCondition;

// @public
export interface RuleDataSource {
    legacyResourceId?: string;
    metricNamespace?: string;
    odataType: "Microsoft.Azure.Management.Insights.Models.RuleMetricDataSource" | "Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource";
    resourceLocation?: string;
    resourceUri?: string;
}

// @public (undocumented)
export type RuleDataSourceUnion = RuleDataSource | RuleMetricDataSource | RuleManagementEventDataSource;

// @public
export type RuleEmailAction = RuleAction & {
    odataType: "Microsoft.Azure.Management.Insights.Models.RuleEmailAction";
    sendToServiceOwners?: boolean;
    customEmails?: string[];
};

// @public
export interface RuleManagementEventClaimsDataSource {
    emailAddress?: string;
}

// @public
export type RuleManagementEventDataSource = RuleDataSource & {
    odataType: "Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource";
    eventName?: string;
    eventSource?: string;
    level?: string;
    operationName?: string;
    resourceGroupName?: string;
    resourceProviderName?: string;
    status?: string;
    subStatus?: string;
    claims?: RuleManagementEventClaimsDataSource;
};

// @public
export type RuleMetricDataSource = RuleDataSource & {
    odataType: "Microsoft.Azure.Management.Insights.Models.RuleMetricDataSource";
    metricName?: string;
};

// @public
export type RuleWebhookAction = RuleAction & {
    odataType: "Microsoft.Azure.Management.Insights.Models.RuleWebhookAction";
    serviceUri?: string;
    properties?: {
        [propertyName: string]: string;
    };
};

// @public
export interface ScaleAction {
    cooldown: string;
    direction: ScaleDirection;
    type: ScaleType;
    value?: string;
}

// @public
export interface ScaleCapacity {
    default: string;
    maximum: string;
    minimum: string;
}

// @public
export type ScaleDirection = "None" | "Increase" | "Decrease";

// @public
export interface ScaleRule {
    metricTrigger: MetricTrigger;
    scaleAction: ScaleAction;
}

// @public
export interface ScaleRuleMetricDimension {
    dimensionName: string;
    operator: ScaleRuleMetricDimensionOperationType;
    values: string[];
}

// @public
export type ScaleRuleMetricDimensionOperationType = string;

// @public
export type ScaleType = "ChangeCount" | "PercentChangeCount" | "ExactCount" | "ServiceAllowedNextValue";

// @public
export interface Schedule {
    frequencyInMinutes: number;
    timeWindowInMinutes: number;
}

// @public
export interface ScheduledQueryRules {
    createOrUpdate(resourceGroupName: string, ruleName: string, parameters: LogSearchRuleResource, options?: ScheduledQueryRulesCreateOrUpdateOptionalParams): Promise<ScheduledQueryRulesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, ruleName: string, options?: ScheduledQueryRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, ruleName: string, options?: ScheduledQueryRulesGetOptionalParams): Promise<ScheduledQueryRulesGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: ScheduledQueryRulesListByResourceGroupOptionalParams): PagedAsyncIterableIterator<LogSearchRuleResource>;
    listBySubscription(options?: ScheduledQueryRulesListBySubscriptionOptionalParams): PagedAsyncIterableIterator<LogSearchRuleResource>;
    update(resourceGroupName: string, ruleName: string, parameters: LogSearchRuleResourcePatch, options?: ScheduledQueryRulesUpdateOptionalParams): Promise<ScheduledQueryRulesUpdateResponse>;
}

// @public
export interface ScheduledQueryRulesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ScheduledQueryRulesCreateOrUpdateResponse = LogSearchRuleResource;

// @public
export interface ScheduledQueryRulesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface ScheduledQueryRulesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ScheduledQueryRulesGetResponse = LogSearchRuleResource;

// @public
export interface ScheduledQueryRulesListByResourceGroupOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type ScheduledQueryRulesListByResourceGroupResponse = LogSearchRuleResourceCollection;

// @public
export interface ScheduledQueryRulesListBySubscriptionOptionalParams extends coreClient.OperationOptions {
    filter?: string;
}

// @public
export type ScheduledQueryRulesListBySubscriptionResponse = LogSearchRuleResourceCollection;

// @public
export interface ScheduledQueryRulesUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type ScheduledQueryRulesUpdateResponse = LogSearchRuleResource;

// @public
export type ScopedResource = ProxyResource & {
    linkedResourceId?: string;
    readonly provisioningState?: string;
};

// @public
export interface ScopedResourceListResult {
    readonly nextLink?: string;
    readonly value?: ScopedResource[];
}

// @public
export interface SenderAuthorization {
    action?: string;
    role?: string;
    scope?: string;
}

// @public
export interface SingleBaseline {
    highThresholds: number[];
    lowThresholds: number[];
    sensitivity: BaselineSensitivity;
}

// @public
export interface SingleMetricBaseline {
    baselines: TimeSeriesBaseline[];
    id: string;
    interval: string;
    name: string;
    namespace?: string;
    timespan: string;
    type: string;
}

// @public
export interface SmsReceiver {
    countryCode: string;
    name: string;
    phoneNumber: string;
    readonly status?: ReceiverStatus;
}

// @public
export interface Source {
    authorizedResources?: string[];
    dataSourceId: string;
    query?: string;
    queryType?: QueryType;
}

// @public
export interface SyslogDataSource {
    facilityNames?: KnownSyslogDataSourceFacilityNames[];
    logLevels?: KnownSyslogDataSourceLogLevels[];
    name?: string;
    streams?: KnownSyslogDataSourceStreams[];
}

// @public
export interface SystemData {
    createdAt?: Date;
    createdBy?: string;
    createdByType?: CreatedByType;
    lastModifiedAt?: Date;
    lastModifiedBy?: string;
    lastModifiedByType?: CreatedByType;
}

// @public
export interface TagsResource {
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export interface TenantActivityLogs {
    list(options?: TenantActivityLogsListOptionalParams): PagedAsyncIterableIterator<EventData>;
}

// @public
export interface TenantActivityLogsListNextOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    select?: string;
}

// @public
export type TenantActivityLogsListNextResponse = EventDataCollection;

// @public
export interface TenantActivityLogsListOptionalParams extends coreClient.OperationOptions {
    filter?: string;
    select?: string;
}

// @public
export type TenantActivityLogsListResponse = EventDataCollection;

// @public
export interface TestNotificationDetailsResponse {
    actionDetails?: ActionDetail[];
    completedTime?: string;
    context?: Context;
    createdTime?: string;
    state: string;
}

// @public
export interface TestNotificationResponse {
    correlationId: string;
    createdTime: string;
    notificationId: string;
}

// @public
export type ThresholdRuleCondition = RuleCondition & {
    odataType: "Microsoft.Azure.Management.Insights.Models.ThresholdRuleCondition";
    operator: ConditionOperator;
    threshold: number;
    windowSize?: string;
    timeAggregation?: TimeAggregationOperator;
};

// @public
export type TimeAggregationOperator = "Average" | "Minimum" | "Maximum" | "Total" | "Last";

// @public
export type TimeAggregationType = "Average" | "Minimum" | "Maximum" | "Total" | "Count" | "Last";

// @public
export interface TimeSeriesBaseline {
    aggregation: string;
    data: SingleBaseline[];
    dimensions?: MetricSingleDimension[];
    metadataValues?: BaselineMetadata[];
    timestamps: Date[];
}

// @public
export interface TimeSeriesElement {
    data?: MetricValue[];
    metadatavalues?: MetadataValue[];
}

// @public
export interface TimeWindow {
    end: Date;
    start: Date;
    timeZone?: string;
}

// @public
export interface TriggerCondition {
    metricTrigger?: LogMetricTrigger;
    threshold: number;
    thresholdOperator: ConditionalOperator;
}

// @public
export interface VMInsights {
    getOnboardingStatus(resourceUri: string, options?: VMInsightsGetOnboardingStatusOptionalParams): Promise<VMInsightsGetOnboardingStatusResponse>;
}

// @public
export interface VMInsightsGetOnboardingStatusOptionalParams extends coreClient.OperationOptions {
}

// @public
export type VMInsightsGetOnboardingStatusResponse = VMInsightsOnboardingStatus;

// @public
export type VMInsightsOnboardingStatus = ProxyResource & {
    resourceId?: string;
    onboardingStatus?: OnboardingStatus;
    dataStatus?: DataStatus;
    data?: DataContainer[];
};

// @public
export interface VoiceReceiver {
    countryCode: string;
    name: string;
    phoneNumber: string;
}

// @public
export interface WebhookNotification {
    properties?: {
        [propertyName: string]: string;
    };
    serviceUri?: string;
}

// @public
export interface WebhookReceiver {
    identifierUri?: string;
    name: string;
    objectId?: string;
    serviceUri: string;
    tenantId?: string;
    useAadAuth?: boolean;
    useCommonAlertSchema?: boolean;
}

// @public
export type WebtestLocationAvailabilityCriteria = MetricAlertCriteria & {
    odataType: "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria";
    webTestId: string;
    componentId: string;
    failedLocationCount: number;
};

// @public
export interface WindowsEventLogDataSource {
    name?: string;
    streams?: KnownWindowsEventLogDataSourceStreams[];
    xPathQueries?: string[];
}

// @public
export interface WorkspaceInfo {
    customerId: string;
    id: string;
    location: string;
}

// (No @packageDocumentation comment for this package)

```