@azure/arm-cloudhealth 1.0.0-alpha.20250619.1

package/dist/esm/models/models.d.ts

@@ -0,0 +1,935 @@
+/** A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results. */
+export interface _OperationListResult {
+    /** The Operation items on this page */
+    value: Operation[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _operationListResultDeserializer(item: any): _OperationListResult;
+export declare function operationArrayDeserializer(result: Array<Operation>): any[];
+/** Details of a REST API operation, returned from the Resource Provider Operations API */
+export interface Operation {
+    /** The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write", "Microsoft.Compute/virtualMachines/capture/action" */
+    readonly name?: string;
+    /** Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure Resource Manager/control-plane operations. */
+    readonly isDataAction?: boolean;
+    /** Localized display information for this particular operation. */
+    display?: OperationDisplay;
+    /** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+    readonly origin?: Origin;
+    /** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+    readonly actionType?: ActionType;
+}
+export declare function operationDeserializer(item: any): Operation;
+/** Localized display information for and operation. */
+export interface OperationDisplay {
+    /** The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft Compute". */
+    readonly provider?: string;
+    /** The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job Schedule Collections". */
+    readonly resource?: string;
+    /** The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual Machine", "Restart Virtual Machine". */
+    readonly operation?: string;
+    /** The short, localized friendly description of the operation; suitable for tool tips and detailed views. */
+    readonly description?: string;
+}
+export declare function operationDisplayDeserializer(item: any): OperationDisplay;
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+export declare enum KnownOrigin {
+    /** Indicates the operation is initiated by a user. */
+    User = "user",
+    /** Indicates the operation is initiated by a system. */
+    System = "system",
+    /** Indicates the operation is initiated by a user or system. */
+    UserSystem = "user,system"
+}
+/**
+ * The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" \
+ * {@link KnownOrigin} can be used interchangeably with Origin,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **user**: Indicates the operation is initiated by a user. \
+ * **system**: Indicates the operation is initiated by a system. \
+ * **user,system**: Indicates the operation is initiated by a user or system.
+ */
+export type Origin = string;
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export declare enum KnownActionType {
+    /** Actions are for internal-only APIs. */
+    Internal = "Internal"
+}
+/**
+ * Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. \
+ * {@link KnownActionType} can be used interchangeably with ActionType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Internal**: Actions are for internal-only APIs.
+ */
+export type ActionType = string;
+/** Common error response for all Azure Resource Manager APIs to return error details for failed operations. */
+export interface ErrorResponse {
+    /** The error object. */
+    error?: ErrorDetail;
+}
+export declare function errorResponseDeserializer(item: any): ErrorResponse;
+/** The error detail. */
+export interface ErrorDetail {
+    /** The error code. */
+    readonly code?: string;
+    /** The error message. */
+    readonly message?: string;
+    /** The error target. */
+    readonly target?: string;
+    /** The error details. */
+    readonly details?: ErrorDetail[];
+    /** The error additional info. */
+    readonly additionalInfo?: ErrorAdditionalInfo[];
+}
+export declare function errorDetailDeserializer(item: any): ErrorDetail;
+export declare function errorDetailArrayDeserializer(result: Array<ErrorDetail>): any[];
+export declare function errorAdditionalInfoArrayDeserializer(result: Array<ErrorAdditionalInfo>): any[];
+/** The resource management error additional info. */
+export interface ErrorAdditionalInfo {
+    /** The additional info type. */
+    readonly type?: string;
+    /** The additional info. */
+    readonly info?: any;
+}
+export declare function errorAdditionalInfoDeserializer(item: any): ErrorAdditionalInfo;
+/** A HealthModel resource */
+export interface HealthModel extends TrackedResource {
+    /** The resource-specific properties for this resource. */
+    properties?: HealthModelProperties;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+}
+export declare function healthModelSerializer(item: HealthModel): any;
+export declare function healthModelDeserializer(item: any): HealthModel;
+/** HealthModel properties */
+export interface HealthModelProperties {
+    /** The data plane endpoint for interacting with health data */
+    readonly dataplaneEndpoint?: string;
+    /** The status of the last operation. */
+    readonly provisioningState?: HealthModelProvisioningState;
+    /** Configure to automatically discover entities from a given scope, such as a Service Group. The discovered entities will be linked to the root entity of the health model. */
+    discovery?: ModelDiscoverySettings;
+}
+export declare function healthModelPropertiesSerializer(item: HealthModelProperties): any;
+export declare function healthModelPropertiesDeserializer(item: any): HealthModelProperties;
+/** Health Model provisioning states */
+export declare enum KnownHealthModelProvisioningState {
+    /** Resource has been created. */
+    Succeeded = "Succeeded",
+    /** Resource creation failed. */
+    Failed = "Failed",
+    /** Resource creation was canceled. */
+    Canceled = "Canceled",
+    Creating = "Creating",
+    Deleting = "Deleting"
+}
+/**
+ * Health Model provisioning states \
+ * {@link KnownHealthModelProvisioningState} can be used interchangeably with HealthModelProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded**: Resource has been created. \
+ * **Failed**: Resource creation failed. \
+ * **Canceled**: Resource creation was canceled. \
+ * **Creating** \
+ * **Deleting**
+ */
+export type HealthModelProvisioningState = string;
+/** Settings for automatically discovering entities for the health model. */
+export interface ModelDiscoverySettings {
+    /** The scope from which entities should be automatically discovered. For example, the resource id of a Service Group. */
+    scope: string;
+    /** Whether to add all recommended signals to the discovered entities. */
+    addRecommendedSignals: DiscoveryRuleRecommendedSignalsBehavior;
+    /** Which Managed Identity of the health model to use for discovery. Defaults to SystemAssigned, if not set. Can be set to 'SystemAssigned' or to the resource id of a user-assigned managed identity which is linked to the health model. */
+    identity?: string;
+}
+export declare function modelDiscoverySettingsSerializer(item: ModelDiscoverySettings): any;
+export declare function modelDiscoverySettingsDeserializer(item: any): ModelDiscoverySettings;
+/** Discovery rule recommended signal behavior */
+export declare enum KnownDiscoveryRuleRecommendedSignalsBehavior {
+    /** Automatically add recommended signals */
+    Enabled = "Enabled",
+    /** Do not automatically add recommended signals */
+    Disabled = "Disabled"
+}
+/**
+ * Discovery rule recommended signal behavior \
+ * {@link KnownDiscoveryRuleRecommendedSignalsBehavior} can be used interchangeably with DiscoveryRuleRecommendedSignalsBehavior,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Automatically add recommended signals \
+ * **Disabled**: Do not automatically add recommended signals
+ */
+export type DiscoveryRuleRecommendedSignalsBehavior = string;
+/** Managed service identity (system assigned and/or user assigned identities) */
+export interface ManagedServiceIdentity {
+    /** The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly principalId?: string;
+    /** The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity. */
+    readonly tenantId?: string;
+    /** The type of managed identity assigned to this resource. */
+    type: ManagedServiceIdentityType;
+    /** The identities assigned to this resource by the user. */
+    userAssignedIdentities?: Record<string, UserAssignedIdentity | null>;
+}
+export declare function managedServiceIdentitySerializer(item: ManagedServiceIdentity): any;
+export declare function managedServiceIdentityDeserializer(item: any): ManagedServiceIdentity;
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+export declare enum KnownManagedServiceIdentityType {
+    /** No managed identity. */
+    None = "None",
+    /** System assigned managed identity. */
+    SystemAssigned = "SystemAssigned",
+    /** User assigned managed identity. */
+    UserAssigned = "UserAssigned",
+    /** System and user assigned managed identity. */
+    SystemAssignedUserAssigned = "SystemAssigned,UserAssigned"
+}
+/**
+ * Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). \
+ * {@link KnownManagedServiceIdentityType} can be used interchangeably with ManagedServiceIdentityType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: No managed identity. \
+ * **SystemAssigned**: System assigned managed identity. \
+ * **UserAssigned**: User assigned managed identity. \
+ * **SystemAssigned,UserAssigned**: System and user assigned managed identity.
+ */
+export type ManagedServiceIdentityType = string;
+/** User assigned identity properties */
+export interface UserAssignedIdentity {
+    /** The principal ID of the assigned identity. */
+    readonly principalId?: string;
+    /** The client ID of the assigned identity. */
+    readonly clientId?: string;
+}
+export declare function userAssignedIdentitySerializer(item: UserAssignedIdentity): any;
+export declare function userAssignedIdentityDeserializer(item: any): UserAssignedIdentity;
+/** The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location' */
+export interface TrackedResource extends Resource {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The geo-location where the resource lives */
+    location: string;
+}
+export declare function trackedResourceSerializer(item: TrackedResource): any;
+export declare function trackedResourceDeserializer(item: any): TrackedResource;
+/** Common fields that are returned in the response for all Azure Resource Manager resources */
+export interface Resource {
+    /** Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name?: string;
+    /** The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" */
+    readonly type?: string;
+    /** Azure Resource Manager metadata containing createdBy and modifiedBy information. */
+    readonly systemData?: SystemData;
+}
+export declare function resourceSerializer(item: Resource): any;
+export declare function resourceDeserializer(item: any): Resource;
+/** Metadata pertaining to creation and last modification of the resource. */
+export interface SystemData {
+    /** The identity that created the resource. */
+    createdBy?: string;
+    /** The type of identity that created the resource. */
+    createdByType?: CreatedByType;
+    /** The timestamp of resource creation (UTC). */
+    createdAt?: Date;
+    /** The identity that last modified the resource. */
+    lastModifiedBy?: string;
+    /** The type of identity that last modified the resource. */
+    lastModifiedByType?: CreatedByType;
+    /** The timestamp of resource last modification (UTC) */
+    lastModifiedAt?: Date;
+}
+export declare function systemDataDeserializer(item: any): SystemData;
+/** The kind of entity that created the resource. */
+export declare enum KnownCreatedByType {
+    /** The entity was created by a user. */
+    User = "User",
+    /** The entity was created by an application. */
+    Application = "Application",
+    /** The entity was created by a managed identity. */
+    ManagedIdentity = "ManagedIdentity",
+    /** The entity was created by a key. */
+    Key = "Key"
+}
+/**
+ * The kind of entity that created the resource. \
+ * {@link KnowncreatedByType} can be used interchangeably with createdByType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **User**: The entity was created by a user. \
+ * **Application**: The entity was created by an application. \
+ * **ManagedIdentity**: The entity was created by a managed identity. \
+ * **Key**: The entity was created by a key.
+ */
+export type CreatedByType = string;
+/** The type used for update operations of the HealthModel. */
+export interface HealthModelUpdate {
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The resource-specific properties for this resource. */
+    properties?: HealthModelUpdateProperties;
+}
+export declare function healthModelUpdateSerializer(item: HealthModelUpdate): any;
+/** The updatable properties of the HealthModel. */
+export interface HealthModelUpdateProperties {
+    /** Configure to automatically discover entities from a given scope, such as a Service Group. The discovered entities will be linked to the root entity of the health model. */
+    discovery?: ModelDiscoverySettings;
+}
+export declare function healthModelUpdatePropertiesSerializer(item: HealthModelUpdateProperties): any;
+/** The response of a HealthModel list operation. */
+export interface _HealthModelListResult {
+    /** The HealthModel items on this page */
+    value: HealthModel[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _healthModelListResultDeserializer(item: any): _HealthModelListResult;
+export declare function healthModelArraySerializer(result: Array<HealthModel>): any[];
+export declare function healthModelArrayDeserializer(result: Array<HealthModel>): any[];
+/** A signal definition in a health model */
+export interface SignalDefinition extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: SignalDefinitionPropertiesUnion;
+}
+export declare function signalDefinitionSerializer(item: SignalDefinition): any;
+export declare function signalDefinitionDeserializer(item: any): SignalDefinition;
+/** SignalDefinition properties */
+export interface SignalDefinitionProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: HealthModelProvisioningState;
+    /** Display name */
+    displayName?: string;
+    /** Kind of the signal definition */
+    /** The discriminator possible values: AzureResourceMetric, LogAnalyticsQuery, PrometheusMetricsQuery */
+    signalKind: SignalKind;
+    /** Interval in which the signal is being evaluated. Defaults to PT1M (1 minute). */
+    refreshInterval?: RefreshInterval;
+    /** Optional set of labels (key-value pairs) */
+    labels?: Record<string, string>;
+    /** Unit of the signal result (e.g. Bytes, MilliSeconds, Percent, Count)) */
+    dataUnit?: string;
+    /** Evaluation rules for the signal definition */
+    evaluationRules: EvaluationRule;
+    /** Date when the signal definition was (soft-)deleted */
+    readonly deletionDate?: Date;
+}
+export declare function signalDefinitionPropertiesSerializer(item: SignalDefinitionProperties): any;
+export declare function signalDefinitionPropertiesDeserializer(item: any): SignalDefinitionProperties;
+/** Alias for SignalDefinitionPropertiesUnion */
+export type SignalDefinitionPropertiesUnion = ResourceMetricSignalDefinitionProperties | LogAnalyticsQuerySignalDefinitionProperties | PrometheusMetricsSignalDefinitionProperties | SignalDefinitionProperties;
+export declare function signalDefinitionPropertiesUnionSerializer(item: SignalDefinitionPropertiesUnion): any;
+export declare function signalDefinitionPropertiesUnionDeserializer(item: any): SignalDefinitionPropertiesUnion;
+/** Supported signal kinds as discriminator */
+export declare enum KnownSignalKind {
+    AzureResourceMetric = "AzureResourceMetric",
+    LogAnalyticsQuery = "LogAnalyticsQuery",
+    PrometheusMetricsQuery = "PrometheusMetricsQuery"
+}
+/**
+ * Supported signal kinds as discriminator \
+ * {@link KnownSignalKind} can be used interchangeably with SignalKind,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AzureResourceMetric** \
+ * **LogAnalyticsQuery** \
+ * **PrometheusMetricsQuery**
+ */
+export type SignalKind = string;
+/** Refresh interval in ISO duration format */
+export declare enum KnownRefreshInterval {
+    /** One Minute */
+    PT1M = "PT1M",
+    /** Five Minutes */
+    PT5M = "PT5M",
+    /** Ten Minutes */
+    PT10M = "PT10M",
+    /** Thirty Minutes */
+    PT30M = "PT30M",
+    /** One Hour */
+    PT1H = "PT1H",
+    /** Two Hours */
+    PT2H = "PT2H"
+}
+/**
+ * Refresh interval in ISO duration format \
+ * {@link KnownRefreshInterval} can be used interchangeably with RefreshInterval,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **PT1M**: One Minute \
+ * **PT5M**: Five Minutes \
+ * **PT10M**: Ten Minutes \
+ * **PT30M**: Thirty Minutes \
+ * **PT1H**: One Hour \
+ * **PT2H**: Two Hours
+ */
+export type RefreshInterval = string;
+/** Evaluation rule for a signal definition */
+export interface EvaluationRule {
+    /** Configure to use ML-based dynamic thresholds. When used, degradedRule and unhealthyRule must not be set. */
+    dynamicDetectionRule?: DynamicDetectionRule;
+    /** Degraded rule with static threshold. When used, dynamicDetectionRule must not be set. */
+    degradedRule?: ThresholdRule;
+    /** Unhealthy rule with static threshold. When used, dynamicDetectionRule must not be set. */
+    unhealthyRule?: ThresholdRule;
+}
+export declare function evaluationRuleSerializer(item: EvaluationRule): any;
+export declare function evaluationRuleDeserializer(item: any): EvaluationRule;
+/** ML-based evaluation rule for a signal definition */
+export interface DynamicDetectionRule {
+    /** ML model to use for dynamic thresholds */
+    dynamicThresholdModel: DynamicThresholdModel;
+    /** ML model sensitivity. Lowest value = high sensitivity. Supported step size = 0.5 */
+    modelSensitivity: number;
+    /** Threshold direction */
+    dynamicThresholdDirection: DynamicThresholdDirection;
+    /** Start time of the training in UTC. */
+    trainingStartTime?: Date;
+}
+export declare function dynamicDetectionRuleSerializer(item: DynamicDetectionRule): any;
+export declare function dynamicDetectionRuleDeserializer(item: any): DynamicDetectionRule;
+/** ML-based model variants */
+export declare enum KnownDynamicThresholdModel {
+    /** Anomaly detection model */
+    AnomalyDetection = "AnomalyDetection"
+}
+/**
+ * ML-based model variants \
+ * {@link KnownDynamicThresholdModel} can be used interchangeably with DynamicThresholdModel,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AnomalyDetection**: Anomaly detection model
+ */
+export type DynamicThresholdModel = string;
+/** Threshold direction for dynamic thresholds */
+export declare enum KnownDynamicThresholdDirection {
+    /** Lower than */
+    LowerThan = "LowerThan",
+    /** Greater than */
+    GreaterThan = "GreaterThan",
+    /** Greater or Lower Than */
+    GreaterOrLowerThan = "GreaterOrLowerThan"
+}
+/**
+ * Threshold direction for dynamic thresholds \
+ * {@link KnownDynamicThresholdDirection} can be used interchangeably with DynamicThresholdDirection,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **LowerThan**: Lower than \
+ * **GreaterThan**: Greater than \
+ * **GreaterOrLowerThan**: Greater or Lower Than
+ */
+export type DynamicThresholdDirection = string;
+/** Threshold-based evaluation rule for a signal definition */
+export interface ThresholdRule {
+    /** Operator how to compare the signal value with the threshold */
+    operator: SignalOperator;
+    /** Threshold value */
+    threshold: string;
+}
+export declare function thresholdRuleSerializer(item: ThresholdRule): any;
+export declare function thresholdRuleDeserializer(item: any): ThresholdRule;
+/** Signal operator */
+export declare enum KnownSignalOperator {
+    /** Lower than */
+    LowerThan = "LowerThan",
+    /** Lower than or equal to */
+    LowerOrEquals = "LowerOrEquals",
+    /** Greater than */
+    GreaterThan = "GreaterThan",
+    /** Greater than or equal to */
+    GreaterOrEquals = "GreaterOrEquals",
+    /** Equal to */
+    Equals = "Equals"
+}
+/**
+ * Signal operator \
+ * {@link KnownSignalOperator} can be used interchangeably with SignalOperator,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **LowerThan**: Lower than \
+ * **LowerOrEquals**: Lower than or equal to \
+ * **GreaterThan**: Greater than \
+ * **GreaterOrEquals**: Greater than or equal to \
+ * **Equals**: Equal to
+ */
+export type SignalOperator = string;
+/** Azure Resource Metric Signal Definition properties */
+export interface ResourceMetricSignalDefinitionProperties extends SignalDefinitionProperties {
+    /** Kind of the signal definition */
+    signalKind: "AzureResourceMetric";
+    /** Metric namespace */
+    metricNamespace: string;
+    /** Name of the metric */
+    metricName: string;
+    /** Time range of signal. ISO duration format like PT10M. */
+    timeGrain: string;
+    /** Type of aggregation to apply to the metric */
+    aggregationType: MetricAggregationType;
+    /** Optional: Dimension to split by */
+    dimension?: string;
+    /** Optional: Dimension filter to apply to the dimension. Must only be set if also Dimension is set. */
+    dimensionFilter?: string;
+}
+export declare function resourceMetricSignalDefinitionPropertiesSerializer(item: ResourceMetricSignalDefinitionProperties): any;
+export declare function resourceMetricSignalDefinitionPropertiesDeserializer(item: any): ResourceMetricSignalDefinitionProperties;
+/** Metric aggregation type */
+export declare enum KnownMetricAggregationType {
+    None = "None",
+    Average = "Average",
+    Count = "Count",
+    Minimum = "Minimum",
+    Maximum = "Maximum",
+    Total = "Total"
+}
+/**
+ * Metric aggregation type \
+ * {@link KnownMetricAggregationType} can be used interchangeably with MetricAggregationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None** \
+ * **Average** \
+ * **Count** \
+ * **Minimum** \
+ * **Maximum** \
+ * **Total**
+ */
+export type MetricAggregationType = string;
+/** Log Analytics Query Signal Definition properties */
+export interface LogAnalyticsQuerySignalDefinitionProperties extends SignalDefinitionProperties {
+    /** Kind of the signal definition */
+    signalKind: "LogAnalyticsQuery";
+    /** Query text in KQL syntax */
+    queryText: string;
+    /** Time range of signal. ISO duration format like PT10M. If not specified, the KQL query must define a time range. */
+    timeGrain?: string;
+    /** Name of the column in the result set to evaluate against the thresholds. Defaults to the first column in the result set if not specified. The column must be numeric. */
+    valueColumnName?: string;
+}
+export declare function logAnalyticsQuerySignalDefinitionPropertiesSerializer(item: LogAnalyticsQuerySignalDefinitionProperties): any;
+export declare function logAnalyticsQuerySignalDefinitionPropertiesDeserializer(item: any): LogAnalyticsQuerySignalDefinitionProperties;
+/** Prometheus Metrics Signal Definition properties */
+export interface PrometheusMetricsSignalDefinitionProperties extends SignalDefinitionProperties {
+    /** Kind of the signal definition */
+    signalKind: "PrometheusMetricsQuery";
+    /** Query text in PromQL syntax */
+    queryText: string;
+    /** Time range of signal. ISO duration format like PT10M. */
+    timeGrain?: string;
+}
+export declare function prometheusMetricsSignalDefinitionPropertiesSerializer(item: PrometheusMetricsSignalDefinitionProperties): any;
+export declare function prometheusMetricsSignalDefinitionPropertiesDeserializer(item: any): PrometheusMetricsSignalDefinitionProperties;
+/** The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location */
+export interface ProxyResource extends Resource {
+}
+export declare function proxyResourceSerializer(item: ProxyResource): any;
+export declare function proxyResourceDeserializer(item: any): ProxyResource;
+/** The response of a SignalDefinition list operation. */
+export interface _SignalDefinitionListResult {
+    /** The SignalDefinition items on this page */
+    value: SignalDefinition[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _signalDefinitionListResultDeserializer(item: any): _SignalDefinitionListResult;
+export declare function signalDefinitionArraySerializer(result: Array<SignalDefinition>): any[];
+export declare function signalDefinitionArrayDeserializer(result: Array<SignalDefinition>): any[];
+/** An authentication setting in a health model */
+export interface AuthenticationSetting extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: AuthenticationSettingPropertiesUnion;
+}
+export declare function authenticationSettingSerializer(item: AuthenticationSetting): any;
+export declare function authenticationSettingDeserializer(item: any): AuthenticationSetting;
+/** Authentication setting properties */
+export interface AuthenticationSettingProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: HealthModelProvisioningState;
+    /** Display name */
+    displayName?: string;
+    /** Kind of the authentication setting */
+    /** The discriminator possible values: ManagedIdentity */
+    authenticationKind: AuthenticationKind;
+}
+export declare function authenticationSettingPropertiesSerializer(item: AuthenticationSettingProperties): any;
+export declare function authenticationSettingPropertiesDeserializer(item: any): AuthenticationSettingProperties;
+/** Alias for AuthenticationSettingPropertiesUnion */
+export type AuthenticationSettingPropertiesUnion = ManagedIdentityAuthenticationSettingProperties | AuthenticationSettingProperties;
+export declare function authenticationSettingPropertiesUnionSerializer(item: AuthenticationSettingPropertiesUnion): any;
+export declare function authenticationSettingPropertiesUnionDeserializer(item: any): AuthenticationSettingPropertiesUnion;
+/** Supported kinds of authentication settings as discriminator */
+export declare enum KnownAuthenticationKind {
+    ManagedIdentity = "ManagedIdentity"
+}
+/**
+ * Supported kinds of authentication settings as discriminator \
+ * {@link KnownAuthenticationKind} can be used interchangeably with AuthenticationKind,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **ManagedIdentity**
+ */
+export type AuthenticationKind = string;
+/** Authentication setting properties for Azure Managed Identity */
+export interface ManagedIdentityAuthenticationSettingProperties extends AuthenticationSettingProperties {
+    /** Kind of the authentication setting */
+    authenticationKind: "ManagedIdentity";
+    /** Name of the managed identity to use. Either 'SystemAssigned' or the resourceId of a user-assigned identity. */
+    managedIdentityName: string;
+}
+export declare function managedIdentityAuthenticationSettingPropertiesSerializer(item: ManagedIdentityAuthenticationSettingProperties): any;
+export declare function managedIdentityAuthenticationSettingPropertiesDeserializer(item: any): ManagedIdentityAuthenticationSettingProperties;
+/** The response of a AuthenticationSetting list operation. */
+export interface _AuthenticationSettingListResult {
+    /** The AuthenticationSetting items on this page */
+    value: AuthenticationSetting[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _authenticationSettingListResultDeserializer(item: any): _AuthenticationSettingListResult;
+export declare function authenticationSettingArraySerializer(result: Array<AuthenticationSetting>): any[];
+export declare function authenticationSettingArrayDeserializer(result: Array<AuthenticationSetting>): any[];
+/** An entity (aka node) of a health model */
+export interface Entity extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: EntityProperties;
+}
+export declare function entitySerializer(item: Entity): any;
+export declare function entityDeserializer(item: any): Entity;
+/** Properties which are common across all kinds of entities */
+export interface EntityProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: HealthModelProvisioningState;
+    /** Display name */
+    displayName?: string;
+    /** Entity kind */
+    kind?: string;
+    /** Positioning of the entity on the model canvas */
+    canvasPosition?: EntityCoordinates;
+    /** Visual icon definition. If not set, a default icon is used. */
+    icon?: IconDefinition;
+    /** Health objective as a percentage of time the entity should be healthy. */
+    healthObjective?: number;
+    /** Impact of the entity in health state propagation */
+    impact?: EntityImpact;
+    /** Optional set of labels (key-value pairs) */
+    labels?: Record<string, string>;
+    /** Signal groups which are assigned to this entity */
+    signals?: SignalGroup;
+    /** Discovered by which discovery rule. If set, the entity cannot be deleted manually. */
+    readonly discoveredBy?: string;
+    /** Date when the entity was (soft-)deleted */
+    readonly deletionDate?: Date;
+    /** Health state of this entity */
+    readonly healthState?: HealthState;
+    /** Alert configuration for this entity */
+    alerts?: EntityAlerts;
+}
+export declare function entityPropertiesSerializer(item: EntityProperties): any;
+export declare function entityPropertiesDeserializer(item: any): EntityProperties;
+/** Visual position of the entity */
+export interface EntityCoordinates {
+    /** X Coordinate */
+    x: number;
+    /** Y Coordinate */
+    y: number;
+}
+export declare function entityCoordinatesSerializer(item: EntityCoordinates): any;
+export declare function entityCoordinatesDeserializer(item: any): EntityCoordinates;
+/** Visual icon definition of an entity */
+export interface IconDefinition {
+    /** Name of the built-in icon, or 'Custom' to use customData */
+    iconName: string;
+    /** Custom data. Base64-encoded SVG data. If set, this overrides the built-in icon. */
+    customData?: string;
+}
+export declare function iconDefinitionSerializer(item: IconDefinition): any;
+export declare function iconDefinitionDeserializer(item: any): IconDefinition;
+/** Type of impact an entity has on health state propagation */
+export declare enum KnownEntityImpact {
+    /** Standard impact */
+    Standard = "Standard",
+    /** Limited impact */
+    Limited = "Limited",
+    /** Suppressed impact */
+    Suppressed = "Suppressed"
+}
+/**
+ * Type of impact an entity has on health state propagation \
+ * {@link KnownEntityImpact} can be used interchangeably with EntityImpact,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Standard**: Standard impact \
+ * **Limited**: Limited impact \
+ * **Suppressed**: Suppressed impact
+ */
+export type EntityImpact = string;
+/** Contains various signal groups that can be assigned to an entity */
+export interface SignalGroup {
+    /** Azure Resource Signal Group */
+    azureResource?: AzureResourceSignalGroup;
+    /** Log Analytics Signal Group */
+    azureLogAnalytics?: LogAnalyticsSignalGroup;
+    /** Azure Monitor Workspace Signal Group */
+    azureMonitorWorkspace?: AzureMonitorWorkspaceSignalGroup;
+    /** Settings for dependency signals to control how the health state of child entities influences the health state of the parent entity. */
+    dependencies?: DependenciesSignalGroup;
+}
+export declare function signalGroupSerializer(item: SignalGroup): any;
+export declare function signalGroupDeserializer(item: any): SignalGroup;
+/** A grouping of signal assignments for an Azure resource */
+export interface AzureResourceSignalGroup {
+    /** Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator. */
+    signalAssignments?: SignalAssignment[];
+    /** Reference to the name of the authentication setting which is used for querying the data source */
+    authenticationSetting: string;
+    /** Azure resource ID */
+    azureResourceId: string;
+}
+export declare function azureResourceSignalGroupSerializer(item: AzureResourceSignalGroup): any;
+export declare function azureResourceSignalGroupDeserializer(item: any): AzureResourceSignalGroup;
+export declare function signalAssignmentArraySerializer(result: Array<SignalAssignment>): any[];
+export declare function signalAssignmentArrayDeserializer(result: Array<SignalAssignment>): any[];
+/** Group of signal definition assignments */
+export interface SignalAssignment {
+    /** Signal definitions referenced by their names. All definitions are combined with an AND operator. */
+    signalDefinitions: string[];
+}
+export declare function signalAssignmentSerializer(item: SignalAssignment): any;
+export declare function signalAssignmentDeserializer(item: any): SignalAssignment;
+/** A grouping of signal assignments for a Log Analytics Workspace */
+export interface LogAnalyticsSignalGroup {
+    /** Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator. */
+    signalAssignments?: SignalAssignment[];
+    /** Reference to the name of the authentication setting which is used for querying the data source */
+    authenticationSetting: string;
+    /** Log Analytics Workspace resource ID */
+    logAnalyticsWorkspaceResourceId: string;
+}
+export declare function logAnalyticsSignalGroupSerializer(item: LogAnalyticsSignalGroup): any;
+export declare function logAnalyticsSignalGroupDeserializer(item: any): LogAnalyticsSignalGroup;
+/** A grouping of signal assignments for a Azure Monitor Workspace */
+export interface AzureMonitorWorkspaceSignalGroup {
+    /** Signal definitions which are assigned to this signal group. All assignments are combined with an OR operator. */
+    signalAssignments?: SignalAssignment[];
+    /** Reference to the name of the authentication setting which is used for querying the data source */
+    authenticationSetting: string;
+    /** Azure Monitor workspace resource ID */
+    azureMonitorWorkspaceResourceId: string;
+}
+export declare function azureMonitorWorkspaceSignalGroupSerializer(item: AzureMonitorWorkspaceSignalGroup): any;
+export declare function azureMonitorWorkspaceSignalGroupDeserializer(item: any): AzureMonitorWorkspaceSignalGroup;
+/** Properties for dependent entities, i.e. child entities */
+export interface DependenciesSignalGroup {
+    /** Aggregation type for child dependencies. */
+    aggregationType: DependenciesAggregationType;
+    /** Degraded threshold for aggregating the propagated health state of child dependencies. Can be either an absolute number that is greater than 0, or a percentage between 1-100%. The entity will be considered degraded when the number of not healthy child dependents (unhealthy, degraded, unknown) is equal to or above the threshold value. Must only be set when AggregationType is 'Thresholds'. */
+    degradedThreshold?: string;
+    /** Unhealthy threshold for aggregating the propagated health state of child dependencies. Can be either an absolute number that is greater than 0, or a percentage between 1-100%. The entity will be considered unhealthy when the number of not healthy child dependents (unhealthy, degraded, unknown) is equal to or above the threshold value. Must only be set when AggregationType is 'Thresholds'. */
+    unhealthyThreshold?: string;
+}
+export declare function dependenciesSignalGroupSerializer(item: DependenciesSignalGroup): any;
+export declare function dependenciesSignalGroupDeserializer(item: any): DependenciesSignalGroup;
+/** Aggregation type for child dependencies. */
+export declare enum KnownDependenciesAggregationType {
+    /** Default behavior: Worst child health state is propagated. */
+    WorstOf = "WorstOf",
+    /** Based on configurable thresholds. */
+    Thresholds = "Thresholds"
+}
+/**
+ * Aggregation type for child dependencies. \
+ * {@link KnownDependenciesAggregationType} can be used interchangeably with DependenciesAggregationType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **WorstOf**: Default behavior: Worst child health state is propagated. \
+ * **Thresholds**: Based on configurable thresholds.
+ */
+export type DependenciesAggregationType = string;
+/** Health state of an entity */
+export declare enum KnownHealthState {
+    /** Healthy status */
+    Healthy = "Healthy",
+    /** Degraded status */
+    Degraded = "Degraded",
+    /** Error status (Unhealthy) */
+    Error = "Error",
+    /** Unknown status */
+    Unknown = "Unknown",
+    /** Deleted status */
+    Deleted = "Deleted"
+}
+/**
+ * Health state of an entity \
+ * {@link KnownHealthState} can be used interchangeably with HealthState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Healthy**: Healthy status \
+ * **Degraded**: Degraded status \
+ * **Error**: Error status (Unhealthy) \
+ * **Unknown**: Unknown status \
+ * **Deleted**: Deleted status
+ */
+export type HealthState = string;
+/** Alert configuration for an entity */
+export interface EntityAlerts {
+    /** Alert to be triggered on state change to unhealthy */
+    unhealthy?: AlertConfiguration;
+    /** Alert to be triggered on state change to degraded */
+    degraded?: AlertConfiguration;
+}
+export declare function entityAlertsSerializer(item: EntityAlerts): any;
+export declare function entityAlertsDeserializer(item: any): EntityAlerts;
+/** Alert configuration details */
+export interface AlertConfiguration {
+    /** The severity of triggered alert. */
+    severity: AlertSeverity;
+    /** The alert rule description. */
+    description?: string;
+    /** Optional list of action group resource IDs to be notified when the alert is triggered. */
+    actionGroupIds?: string[];
+}
+export declare function alertConfigurationSerializer(item: AlertConfiguration): any;
+export declare function alertConfigurationDeserializer(item: any): AlertConfiguration;
+/** Severity of an alert */
+export declare enum KnownAlertSeverity {
+    /** Critical */
+    Sev0 = "Sev0",
+    /** Error */
+    Sev1 = "Sev1",
+    /** Warning */
+    Sev2 = "Sev2",
+    /** Informational */
+    Sev3 = "Sev3",
+    /** Verbose */
+    Sev4 = "Sev4"
+}
+/**
+ * Severity of an alert \
+ * {@link KnownAlertSeverity} can be used interchangeably with AlertSeverity,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Sev0**: Critical \
+ * **Sev1**: Error \
+ * **Sev2**: Warning \
+ * **Sev3**: Informational \
+ * **Sev4**: Verbose
+ */
+export type AlertSeverity = string;
+/** The response of a Entity list operation. */
+export interface _EntityListResult {
+    /** The Entity items on this page */
+    value: Entity[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _entityListResultDeserializer(item: any): _EntityListResult;
+export declare function entityArraySerializer(result: Array<Entity>): any[];
+export declare function entityArrayDeserializer(result: Array<Entity>): any[];
+/** A relationship (aka edge) between two entities in a health model */
+export interface Relationship extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: RelationshipProperties;
+}
+export declare function relationshipSerializer(item: Relationship): any;
+export declare function relationshipDeserializer(item: any): Relationship;
+/** Relationship properties */
+export interface RelationshipProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: HealthModelProvisioningState;
+    /** Display name */
+    displayName?: string;
+    /** Resource name of the parent entity */
+    parentEntityName: string;
+    /** Resource name of the child entity */
+    childEntityName: string;
+    /** Optional set of labels (key-value pairs) */
+    labels?: Record<string, string>;
+    /** Discovered by which discovery rule. If set, the relationship cannot be deleted manually. */
+    readonly discoveredBy?: string;
+    /** Date when the relationship was (soft-)deleted */
+    readonly deletionDate?: Date;
+}
+export declare function relationshipPropertiesSerializer(item: RelationshipProperties): any;
+export declare function relationshipPropertiesDeserializer(item: any): RelationshipProperties;
+/** The response of a Relationship list operation. */
+export interface _RelationshipListResult {
+    /** The Relationship items on this page */
+    value: Relationship[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _relationshipListResultDeserializer(item: any): _RelationshipListResult;
+export declare function relationshipArraySerializer(result: Array<Relationship>): any[];
+export declare function relationshipArrayDeserializer(result: Array<Relationship>): any[];
+/** A discovery rule which automatically finds entities and relationships in a health model based on an Azure Resource Graph query */
+export interface DiscoveryRule extends ProxyResource {
+    /** The resource-specific properties for this resource. */
+    properties?: DiscoveryRuleProperties;
+}
+export declare function discoveryRuleSerializer(item: DiscoveryRule): any;
+export declare function discoveryRuleDeserializer(item: any): DiscoveryRule;
+/** Discovery rule properties */
+export interface DiscoveryRuleProperties {
+    /** The status of the last operation. */
+    readonly provisioningState?: HealthModelProvisioningState;
+    /** Display name */
+    displayName?: string;
+    /** Azure Resource Graph query text in KQL syntax. The query must return at least a column named 'id' which contains the resource ID of the discovered resources. */
+    resourceGraphQuery: string;
+    /** Reference to the name of the authentication setting which is used for querying Azure Resource Graph. The same authentication setting will also be assigned to any discovered entities. */
+    authenticationSetting: string;
+    /** Whether to create relationships between the discovered entities based on a set of built-in rules. These relationships cannot be manually deleted. */
+    discoverRelationships: DiscoveryRuleRelationshipDiscoveryBehavior;
+    /** Whether to add all recommended signals to the discovered entities. */
+    addRecommendedSignals: DiscoveryRuleRecommendedSignalsBehavior;
+    /** Date when the discovery rule was (soft-)deleted. */
+    readonly deletionDate?: Date;
+    /** Error message if the last discovery operation failed. */
+    readonly errorMessage?: string;
+    /** Number of discovered entities in the last discovery operation. */
+    readonly numberOfDiscoveredEntities?: number;
+    /** Name of the entity which represents the discovery rule. Note: It might take a few minutes after creating the discovery rule until the entity is created. */
+    readonly entityName: string;
+}
+export declare function discoveryRulePropertiesSerializer(item: DiscoveryRuleProperties): any;
+export declare function discoveryRulePropertiesDeserializer(item: any): DiscoveryRuleProperties;
+/** Discovery rule relationship discovery behavior */
+export declare enum KnownDiscoveryRuleRelationshipDiscoveryBehavior {
+    /** Automatically attempt to discover relationships */
+    Enabled = "Enabled",
+    /** Do not automatically attempt to discover relationships */
+    Disabled = "Disabled"
+}
+/**
+ * Discovery rule relationship discovery behavior \
+ * {@link KnownDiscoveryRuleRelationshipDiscoveryBehavior} can be used interchangeably with DiscoveryRuleRelationshipDiscoveryBehavior,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Automatically attempt to discover relationships \
+ * **Disabled**: Do not automatically attempt to discover relationships
+ */
+export type DiscoveryRuleRelationshipDiscoveryBehavior = string;
+/** The response of a DiscoveryRule list operation. */
+export interface _DiscoveryRuleListResult {
+    /** The DiscoveryRule items on this page */
+    value: DiscoveryRule[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _discoveryRuleListResultDeserializer(item: any): _DiscoveryRuleListResult;
+export declare function discoveryRuleArraySerializer(result: Array<DiscoveryRule>): any[];
+export declare function discoveryRuleArrayDeserializer(result: Array<DiscoveryRule>): any[];
+/** API Versions */
+export declare enum KnownVersions {
+    /** 2025-05-01-preview */
+    V20250501Preview = "2025-05-01-preview"
+}
+//# sourceMappingURL=models.d.ts.map