pulumi-azure-native 2.39.1a1714471729__py3-none-any.whl → 2.40.0__py3-none-any.whl

pulumi_azure_native/monitor/outputs.py

@@ -9,329 +9,1396 @@ import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 from . import outputs
+from ._enums import *
 
 __all__ = [
+    'AzureMonitorWorkspaceLogsApiConfigResponse',
+    'AzureMonitorWorkspaceLogsExporterResponse',
     'AzureMonitorWorkspaceResponseDefaultIngestionSettings',
     'AzureMonitorWorkspaceResponseMetrics',
+    'BatchProcessorResponse',
+    'CacheConfigurationResponse',
+    'ConcurrencyConfigurationResponse',
+    'ExporterResponse',
+    'ExtendedLocationResponse',
+    'NetworkingConfigurationResponse',
+    'NetworkingRouteResponse',
+    'OtlpReceiverResponse',
+    'PersistenceConfigurationsResponse',
+    'PipelineResponse',
     'PrivateEndpointConnectionResponse',
     'PrivateEndpointResponse',
     'PrivateLinkServiceConnectionStateResponse',
+    'ProcessorResponse',
+    'ReceiverResponse',
+    'RecordMapResponse',
+    'ResourceMapResponse',
+    'SchemaMapResponse',
+    'ScopeMapResponse',
+    'ServiceResponse',
+    'SyslogReceiverResponse',
     'SystemDataResponse',
+    'TcpExporterResponse',
+    'UdpReceiverResponse',
 ]
 
+@pulumi.output_type
+class AzureMonitorWorkspaceLogsApiConfigResponse(dict):
+    """
+    Azure Monitor Workspace Logs Api configurations.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dataCollectionEndpointUrl":
+            suggest = "data_collection_endpoint_url"
+        elif key == "dataCollectionRule":
+            suggest = "data_collection_rule"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureMonitorWorkspaceLogsApiConfigResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureMonitorWorkspaceLogsApiConfigResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureMonitorWorkspaceLogsApiConfigResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data_collection_endpoint_url: str,
+                 data_collection_rule: str,
+                 schema: 'outputs.SchemaMapResponse',
+                 stream: str):
+        """
+        Azure Monitor Workspace Logs Api configurations.
+        :param str data_collection_endpoint_url: Data collection endpoint ingestion url.
+        :param str data_collection_rule: Data Collection Rule (DCR) immutable id.
+        :param 'SchemaMapResponse' schema: The schema mapping for incoming data.
+        :param str stream: Stream name in destination. Azure Monitor stream is related to the destination table.
+        """
+        pulumi.set(__self__, "data_collection_endpoint_url", data_collection_endpoint_url)
+        pulumi.set(__self__, "data_collection_rule", data_collection_rule)
+        pulumi.set(__self__, "schema", schema)
+        pulumi.set(__self__, "stream", stream)
+
+    @property
+    @pulumi.getter(name="dataCollectionEndpointUrl")
+    def data_collection_endpoint_url(self) -> str:
+        """
+        Data collection endpoint ingestion url.
+        """
+        return pulumi.get(self, "data_collection_endpoint_url")
+
+    @property
+    @pulumi.getter(name="dataCollectionRule")
+    def data_collection_rule(self) -> str:
+        """
+        Data Collection Rule (DCR) immutable id.
+        """
+        return pulumi.get(self, "data_collection_rule")
+
+    @property
+    @pulumi.getter
+    def schema(self) -> 'outputs.SchemaMapResponse':
+        """
+        The schema mapping for incoming data.
+        """
+        return pulumi.get(self, "schema")
+
+    @property
+    @pulumi.getter
+    def stream(self) -> str:
+        """
+        Stream name in destination. Azure Monitor stream is related to the destination table.
+        """
+        return pulumi.get(self, "stream")
+
+
+@pulumi.output_type
+class AzureMonitorWorkspaceLogsExporterResponse(dict):
+    """
+    Azure Monitor Workspace Logs specific configurations.
+    """
+    def __init__(__self__, *,
+                 api: 'outputs.AzureMonitorWorkspaceLogsApiConfigResponse',
+                 cache: Optional['outputs.CacheConfigurationResponse'] = None,
+                 concurrency: Optional['outputs.ConcurrencyConfigurationResponse'] = None):
+        """
+        Azure Monitor Workspace Logs specific configurations.
+        :param 'AzureMonitorWorkspaceLogsApiConfigResponse' api: API configurations for Azure Monitor workspace exporter.
+        :param 'CacheConfigurationResponse' cache: Cache configurations.
+        :param 'ConcurrencyConfigurationResponse' concurrency: Concurrency configuration for the exporter.
+        """
+        pulumi.set(__self__, "api", api)
+        if cache is not None:
+            pulumi.set(__self__, "cache", cache)
+        if concurrency is not None:
+            pulumi.set(__self__, "concurrency", concurrency)
+
+    @property
+    @pulumi.getter
+    def api(self) -> 'outputs.AzureMonitorWorkspaceLogsApiConfigResponse':
+        """
+        API configurations for Azure Monitor workspace exporter.
+        """
+        return pulumi.get(self, "api")
+
+    @property
+    @pulumi.getter
+    def cache(self) -> Optional['outputs.CacheConfigurationResponse']:
+        """
+        Cache configurations.
+        """
+        return pulumi.get(self, "cache")
+
+    @property
+    @pulumi.getter
+    def concurrency(self) -> Optional['outputs.ConcurrencyConfigurationResponse']:
+        """
+        Concurrency configuration for the exporter.
+        """
+        return pulumi.get(self, "concurrency")
+
+
 @pulumi.output_type
 class AzureMonitorWorkspaceResponseDefaultIngestionSettings(dict):
     """
-    The Data Collection Rule and Endpoint used for ingestion by default.
+    The Data Collection Rule and Endpoint used for ingestion by default.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dataCollectionEndpointResourceId":
+            suggest = "data_collection_endpoint_resource_id"
+        elif key == "dataCollectionRuleResourceId":
+            suggest = "data_collection_rule_resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureMonitorWorkspaceResponseDefaultIngestionSettings. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureMonitorWorkspaceResponseDefaultIngestionSettings.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureMonitorWorkspaceResponseDefaultIngestionSettings.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data_collection_endpoint_resource_id: str,
+                 data_collection_rule_resource_id: str):
+        """
+        The Data Collection Rule and Endpoint used for ingestion by default.
+        :param str data_collection_endpoint_resource_id: The Azure resource Id of the default data collection endpoint for this Azure Monitor Workspace.
+        :param str data_collection_rule_resource_id: The Azure resource Id of the default data collection rule for this Azure Monitor Workspace.
+        """
+        pulumi.set(__self__, "data_collection_endpoint_resource_id", data_collection_endpoint_resource_id)
+        pulumi.set(__self__, "data_collection_rule_resource_id", data_collection_rule_resource_id)
+
+    @property
+    @pulumi.getter(name="dataCollectionEndpointResourceId")
+    def data_collection_endpoint_resource_id(self) -> str:
+        """
+        The Azure resource Id of the default data collection endpoint for this Azure Monitor Workspace.
+        """
+        return pulumi.get(self, "data_collection_endpoint_resource_id")
+
+    @property
+    @pulumi.getter(name="dataCollectionRuleResourceId")
+    def data_collection_rule_resource_id(self) -> str:
+        """
+        The Azure resource Id of the default data collection rule for this Azure Monitor Workspace.
+        """
+        return pulumi.get(self, "data_collection_rule_resource_id")
+
+
+@pulumi.output_type
+class AzureMonitorWorkspaceResponseMetrics(dict):
+    """
+    Properties related to the metrics container in the Azure Monitor Workspace
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "internalId":
+            suggest = "internal_id"
+        elif key == "prometheusQueryEndpoint":
+            suggest = "prometheus_query_endpoint"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AzureMonitorWorkspaceResponseMetrics. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AzureMonitorWorkspaceResponseMetrics.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AzureMonitorWorkspaceResponseMetrics.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 internal_id: str,
+                 prometheus_query_endpoint: str):
+        """
+        Properties related to the metrics container in the Azure Monitor Workspace
+        :param str internal_id: An internal identifier for the metrics container. Only to be used by the system
+        :param str prometheus_query_endpoint: The Prometheus query endpoint for the Azure Monitor Workspace
+        """
+        pulumi.set(__self__, "internal_id", internal_id)
+        pulumi.set(__self__, "prometheus_query_endpoint", prometheus_query_endpoint)
+
+    @property
+    @pulumi.getter(name="internalId")
+    def internal_id(self) -> str:
+        """
+        An internal identifier for the metrics container. Only to be used by the system
+        """
+        return pulumi.get(self, "internal_id")
+
+    @property
+    @pulumi.getter(name="prometheusQueryEndpoint")
+    def prometheus_query_endpoint(self) -> str:
+        """
+        The Prometheus query endpoint for the Azure Monitor Workspace
+        """
+        return pulumi.get(self, "prometheus_query_endpoint")
+
+
+@pulumi.output_type
+class BatchProcessorResponse(dict):
+    """
+    Batch processor.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "batchSize":
+            suggest = "batch_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BatchProcessorResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BatchProcessorResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BatchProcessorResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 batch_size: Optional[int] = None,
+                 timeout: Optional[int] = None):
+        """
+        Batch processor.
+        :param int batch_size: Size of the batch.
+        :param int timeout: Timeout in milliseconds.
+        """
+        if batch_size is None:
+            batch_size = 8192
+        if batch_size is not None:
+            pulumi.set(__self__, "batch_size", batch_size)
+        if timeout is None:
+            timeout = 200
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+
+    @property
+    @pulumi.getter(name="batchSize")
+    def batch_size(self) -> Optional[int]:
+        """
+        Size of the batch.
+        """
+        return pulumi.get(self, "batch_size")
+
+    @property
+    @pulumi.getter
+    def timeout(self) -> Optional[int]:
+        """
+        Timeout in milliseconds.
+        """
+        return pulumi.get(self, "timeout")
+
+
+@pulumi.output_type
+class CacheConfigurationResponse(dict):
+    """
+    Cache configurations.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxStorageUsage":
+            suggest = "max_storage_usage"
+        elif key == "retentionPeriod":
+            suggest = "retention_period"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_storage_usage: Optional[int] = None,
+                 retention_period: Optional[int] = None):
+        """
+        Cache configurations.
+        :param int max_storage_usage: Max storage usage in megabytes.
+        :param int retention_period: Retention period in minutes.
+        """
+        if max_storage_usage is not None:
+            pulumi.set(__self__, "max_storage_usage", max_storage_usage)
+        if retention_period is not None:
+            pulumi.set(__self__, "retention_period", retention_period)
+
+    @property
+    @pulumi.getter(name="maxStorageUsage")
+    def max_storage_usage(self) -> Optional[int]:
+        """
+        Max storage usage in megabytes.
+        """
+        return pulumi.get(self, "max_storage_usage")
+
+    @property
+    @pulumi.getter(name="retentionPeriod")
+    def retention_period(self) -> Optional[int]:
+        """
+        Retention period in minutes.
+        """
+        return pulumi.get(self, "retention_period")
+
+
+@pulumi.output_type
+class ConcurrencyConfigurationResponse(dict):
+    """
+    Concurrent publishing configuration.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "batchQueueSize":
+            suggest = "batch_queue_size"
+        elif key == "workerCount":
+            suggest = "worker_count"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConcurrencyConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConcurrencyConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConcurrencyConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 batch_queue_size: Optional[int] = None,
+                 worker_count: Optional[int] = None):
+        """
+        Concurrent publishing configuration.
+        :param int batch_queue_size: Size of the queue for log batches.
+        :param int worker_count: Number of parallel workers processing the log queues.
+        """
+        if batch_queue_size is None:
+            batch_queue_size = 100
+        if batch_queue_size is not None:
+            pulumi.set(__self__, "batch_queue_size", batch_queue_size)
+        if worker_count is None:
+            worker_count = 4
+        if worker_count is not None:
+            pulumi.set(__self__, "worker_count", worker_count)
+
+    @property
+    @pulumi.getter(name="batchQueueSize")
+    def batch_queue_size(self) -> Optional[int]:
+        """
+        Size of the queue for log batches.
+        """
+        return pulumi.get(self, "batch_queue_size")
+
+    @property
+    @pulumi.getter(name="workerCount")
+    def worker_count(self) -> Optional[int]:
+        """
+        Number of parallel workers processing the log queues.
+        """
+        return pulumi.get(self, "worker_count")
+
+
+@pulumi.output_type
+class ExporterResponse(dict):
+    """
+    Exporter Info.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "azureMonitorWorkspaceLogs":
+            suggest = "azure_monitor_workspace_logs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExporterResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExporterResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExporterResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 name: str,
+                 type: str,
+                 azure_monitor_workspace_logs: Optional['outputs.AzureMonitorWorkspaceLogsExporterResponse'] = None,
+                 tcp: Optional['outputs.TcpExporterResponse'] = None):
+        """
+        Exporter Info.
+        :param str name: The name of exporter.
+        :param str type: The type of exporter.
+        :param 'AzureMonitorWorkspaceLogsExporterResponse' azure_monitor_workspace_logs: Azure Monitor Workspace Logs specific configurations.
+        :param 'TcpExporterResponse' tcp: TCP based exporter. Used for pipelineGroup exporter.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+        if azure_monitor_workspace_logs is not None:
+            pulumi.set(__self__, "azure_monitor_workspace_logs", azure_monitor_workspace_logs)
+        if tcp is not None:
+            pulumi.set(__self__, "tcp", tcp)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of exporter.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of exporter.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="azureMonitorWorkspaceLogs")
+    def azure_monitor_workspace_logs(self) -> Optional['outputs.AzureMonitorWorkspaceLogsExporterResponse']:
+        """
+        Azure Monitor Workspace Logs specific configurations.
+        """
+        return pulumi.get(self, "azure_monitor_workspace_logs")
+
+    @property
+    @pulumi.getter
+    def tcp(self) -> Optional['outputs.TcpExporterResponse']:
+        """
+        TCP based exporter. Used for pipelineGroup exporter.
+        """
+        return pulumi.get(self, "tcp")
+
+
+@pulumi.output_type
+class ExtendedLocationResponse(dict):
+    """
+    The extended location info.
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 type: str):
+        """
+        The extended location info.
+        :param str name: The name of extended location.
+        :param str type: The type of extended location.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of extended location.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of extended location.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class NetworkingConfigurationResponse(dict):
+    """
+    Networking configuration for the pipeline group instance.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "externalNetworkingMode":
+            suggest = "external_networking_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkingConfigurationResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkingConfigurationResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkingConfigurationResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 external_networking_mode: str,
+                 routes: Sequence['outputs.NetworkingRouteResponse'],
+                 host: Optional[str] = None):
+        """
+        Networking configuration for the pipeline group instance.
+        :param str external_networking_mode: External networking mode.
+        :param Sequence['NetworkingRouteResponse'] routes: Networking routes configuration.
+        :param str host: The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
+        """
+        pulumi.set(__self__, "external_networking_mode", external_networking_mode)
+        pulumi.set(__self__, "routes", routes)
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+
+    @property
+    @pulumi.getter(name="externalNetworkingMode")
+    def external_networking_mode(self) -> str:
+        """
+        External networking mode.
+        """
+        return pulumi.get(self, "external_networking_mode")
+
+    @property
+    @pulumi.getter
+    def routes(self) -> Sequence['outputs.NetworkingRouteResponse']:
+        """
+        Networking routes configuration.
+        """
+        return pulumi.get(self, "routes")
+
+    @property
+    @pulumi.getter
+    def host(self) -> Optional[str]:
+        """
+        The address exposed on the cluster. Example: azuremonitorpipeline.contoso.com.
+        """
+        return pulumi.get(self, "host")
+
+
+@pulumi.output_type
+class NetworkingRouteResponse(dict):
+    """
+    Networking route configuration.
+    """
+    def __init__(__self__, *,
+                 receiver: str,
+                 path: Optional[str] = None,
+                 port: Optional[int] = None,
+                 subdomain: Optional[str] = None):
+        """
+        Networking route configuration.
+        :param str receiver: The name of the previously defined receiver.
+        :param str path: Route path.
+        :param int port: The port that will be configured externally. If not specified, it will use the port from the receiver definition.
+        :param str subdomain: Route subdomain.
+        """
+        pulumi.set(__self__, "receiver", receiver)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if subdomain is not None:
+            pulumi.set(__self__, "subdomain", subdomain)
+
+    @property
+    @pulumi.getter
+    def receiver(self) -> str:
+        """
+        The name of the previously defined receiver.
+        """
+        return pulumi.get(self, "receiver")
+
+    @property
+    @pulumi.getter
+    def path(self) -> Optional[str]:
+        """
+        Route path.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[int]:
+        """
+        The port that will be configured externally. If not specified, it will use the port from the receiver definition.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter
+    def subdomain(self) -> Optional[str]:
+        """
+        Route subdomain.
+        """
+        return pulumi.get(self, "subdomain")
+
+
+@pulumi.output_type
+class OtlpReceiverResponse(dict):
+    """
+    OTLP Receiver.
+    """
+    def __init__(__self__, *,
+                 endpoint: str):
+        """
+        OTLP Receiver.
+        :param str endpoint: OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
+        """
+        pulumi.set(__self__, "endpoint", endpoint)
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> str:
+        """
+        OTLP GRPC endpoint definition. Example: 0.0.0.0:<port>.
+        """
+        return pulumi.get(self, "endpoint")
+
+
+@pulumi.output_type
+class PersistenceConfigurationsResponse(dict):
+    """
+    Persistence options to all pipelines in the instance.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "persistentVolumeName":
+            suggest = "persistent_volume_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PersistenceConfigurationsResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PersistenceConfigurationsResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PersistenceConfigurationsResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 persistent_volume_name: str):
+        """
+        Persistence options to all pipelines in the instance.
+        :param str persistent_volume_name: The name of the mounted persistent volume.
+        """
+        pulumi.set(__self__, "persistent_volume_name", persistent_volume_name)
+
+    @property
+    @pulumi.getter(name="persistentVolumeName")
+    def persistent_volume_name(self) -> str:
+        """
+        The name of the mounted persistent volume.
+        """
+        return pulumi.get(self, "persistent_volume_name")
+
+
+@pulumi.output_type
+class PipelineResponse(dict):
+    """
+    Pipeline Info.
+    """
+    def __init__(__self__, *,
+                 exporters: Sequence[str],
+                 name: str,
+                 receivers: Sequence[str],
+                 type: str,
+                 processors: Optional[Sequence[str]] = None):
+        """
+        Pipeline Info.
+        :param Sequence[str] exporters: Reference to exporters configured for the pipeline.
+        :param str name: Name of the pipeline.
+        :param Sequence[str] receivers: Reference to receivers configured for the pipeline.
+        :param str type: The type of pipeline
+        :param Sequence[str] processors: Reference to processors configured for the pipeline.
+        """
+        pulumi.set(__self__, "exporters", exporters)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "receivers", receivers)
+        pulumi.set(__self__, "type", type)
+        if processors is not None:
+            pulumi.set(__self__, "processors", processors)
+
+    @property
+    @pulumi.getter
+    def exporters(self) -> Sequence[str]:
+        """
+        Reference to exporters configured for the pipeline.
+        """
+        return pulumi.get(self, "exporters")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name of the pipeline.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def receivers(self) -> Sequence[str]:
+        """
+        Reference to receivers configured for the pipeline.
+        """
+        return pulumi.get(self, "receivers")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of pipeline
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def processors(self) -> Optional[Sequence[str]]:
+        """
+        Reference to processors configured for the pipeline.
+        """
+        return pulumi.get(self, "processors")
+
+
+@pulumi.output_type
+class PrivateEndpointConnectionResponse(dict):
+    """
+    The private endpoint connection resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "groupIds":
+            suggest = "group_ids"
+        elif key == "privateLinkServiceConnectionState":
+            suggest = "private_link_service_connection_state"
+        elif key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "systemData":
+            suggest = "system_data"
+        elif key == "privateEndpoint":
+            suggest = "private_endpoint"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrivateEndpointConnectionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrivateEndpointConnectionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrivateEndpointConnectionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 group_ids: Sequence[str],
+                 id: str,
+                 name: str,
+                 private_link_service_connection_state: 'outputs.PrivateLinkServiceConnectionStateResponse',
+                 provisioning_state: str,
+                 system_data: 'outputs.SystemDataResponse',
+                 type: str,
+                 private_endpoint: Optional['outputs.PrivateEndpointResponse'] = None):
+        """
+        The private endpoint connection resource.
+        :param Sequence[str] group_ids: The group ids for the private endpoint resource.
+        :param str id: Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
+        :param str name: The name of the resource
+        :param 'PrivateLinkServiceConnectionStateResponse' private_link_service_connection_state: A collection of information about the state of the connection between service consumer and provider.
+        :param str provisioning_state: The provisioning state of the private endpoint connection resource.
+        :param 'SystemDataResponse' system_data: Azure Resource Manager metadata containing createdBy and modifiedBy information.
+        :param str type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        :param 'PrivateEndpointResponse' private_endpoint: The private endpoint resource.
+        """
+        pulumi.set(__self__, "group_ids", group_ids)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "system_data", system_data)
+        pulumi.set(__self__, "type", type)
+        if private_endpoint is not None:
+            pulumi.set(__self__, "private_endpoint", private_endpoint)
+
+    @property
+    @pulumi.getter(name="groupIds")
+    def group_ids(self) -> Sequence[str]:
+        """
+        The group ids for the private endpoint resource.
+        """
+        return pulumi.get(self, "group_ids")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the resource
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="privateLinkServiceConnectionState")
+    def private_link_service_connection_state(self) -> 'outputs.PrivateLinkServiceConnectionStateResponse':
+        """
+        A collection of information about the state of the connection between service consumer and provider.
+        """
+        return pulumi.get(self, "private_link_service_connection_state")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The provisioning state of the private endpoint connection resource.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="systemData")
+    def system_data(self) -> 'outputs.SystemDataResponse':
+        """
+        Azure Resource Manager metadata containing createdBy and modifiedBy information.
+        """
+        return pulumi.get(self, "system_data")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="privateEndpoint")
+    def private_endpoint(self) -> Optional['outputs.PrivateEndpointResponse']:
+        """
+        The private endpoint resource.
+        """
+        return pulumi.get(self, "private_endpoint")
+
+
+@pulumi.output_type
+class PrivateEndpointResponse(dict):
+    """
+    The private endpoint resource.
+    """
+    def __init__(__self__, *,
+                 id: str):
+        """
+        The private endpoint resource.
+        :param str id: The ARM identifier for private endpoint.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ARM identifier for private endpoint.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class PrivateLinkServiceConnectionStateResponse(dict):
+    """
+    A collection of information about the state of the connection between service consumer and provider.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionsRequired":
+            suggest = "actions_required"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkServiceConnectionStateResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 actions_required: Optional[str] = None,
+                 description: Optional[str] = None,
+                 status: Optional[str] = None):
+        """
+        A collection of information about the state of the connection between service consumer and provider.
+        :param str actions_required: A message indicating if changes on the service provider require any updates on the consumer.
+        :param str description: The reason for approval/rejection of the connection.
+        :param str status: Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        """
+        if actions_required is not None:
+            pulumi.set(__self__, "actions_required", actions_required)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="actionsRequired")
+    def actions_required(self) -> Optional[str]:
+        """
+        A message indicating if changes on the service provider require any updates on the consumer.
+        """
+        return pulumi.get(self, "actions_required")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        The reason for approval/rejection of the connection.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class ProcessorResponse(dict):
+    """
+    Processor Info.
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 type: str,
+                 batch: Optional['outputs.BatchProcessorResponse'] = None):
+        """
+        Processor Info.
+        :param str name: The name of processor.
+        :param str type: The type of processor.
+        :param 'BatchProcessorResponse' batch: Batch processor configurations.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+        if batch is not None:
+            pulumi.set(__self__, "batch", batch)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of processor.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of processor.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def batch(self) -> Optional['outputs.BatchProcessorResponse']:
+        """
+        Batch processor configurations.
+        """
+        return pulumi.get(self, "batch")
+
+
+@pulumi.output_type
+class ReceiverResponse(dict):
+    """
+    Receiver Info.
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 type: str,
+                 otlp: Optional['outputs.OtlpReceiverResponse'] = None,
+                 syslog: Optional['outputs.SyslogReceiverResponse'] = None,
+                 udp: Optional['outputs.UdpReceiverResponse'] = None):
+        """
+        Receiver Info.
+        :param str name: The name of receiver.
+        :param str type: The type of receiver.
+        :param 'OtlpReceiverResponse' otlp: OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        :param 'SyslogReceiverResponse' syslog: Syslog configurations. This field is mandatory for syslog type receivers.
+        :param 'UdpReceiverResponse' udp: UDP receiver configurations. This field is mandatory for UDP receivers.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "type", type)
+        if otlp is not None:
+            pulumi.set(__self__, "otlp", otlp)
+        if syslog is not None:
+            pulumi.set(__self__, "syslog", syslog)
+        if udp is not None:
+            pulumi.set(__self__, "udp", udp)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of receiver.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of receiver.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def otlp(self) -> Optional['outputs.OtlpReceiverResponse']:
+        """
+        OTLP receiver configurations. This field is mandatory for OTLP and pipelineGroup receivers.
+        """
+        return pulumi.get(self, "otlp")
+
+    @property
+    @pulumi.getter
+    def syslog(self) -> Optional['outputs.SyslogReceiverResponse']:
+        """
+        Syslog configurations. This field is mandatory for syslog type receivers.
+        """
+        return pulumi.get(self, "syslog")
+
+    @property
+    @pulumi.getter
+    def udp(self) -> Optional['outputs.UdpReceiverResponse']:
+        """
+        UDP receiver configurations. This field is mandatory for UDP receivers.
+        """
+        return pulumi.get(self, "udp")
+
+
+@pulumi.output_type
+class RecordMapResponse(dict):
+    """
+    Record map for schema in azure monitor.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "dataCollectionEndpointResourceId":
-            suggest = "data_collection_endpoint_resource_id"
-        elif key == "dataCollectionRuleResourceId":
-            suggest = "data_collection_rule_resource_id"
+        if key == "from":
+            suggest = "from_"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureMonitorWorkspaceResponseDefaultIngestionSettings. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in RecordMapResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        AzureMonitorWorkspaceResponseDefaultIngestionSettings.__key_warning(key)
+        RecordMapResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        AzureMonitorWorkspaceResponseDefaultIngestionSettings.__key_warning(key)
+        RecordMapResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 data_collection_endpoint_resource_id: str,
-                 data_collection_rule_resource_id: str):
+                 from_: str,
+                 to: str):
         """
-        The Data Collection Rule and Endpoint used for ingestion by default.
-        :param str data_collection_endpoint_resource_id: The Azure resource Id of the default data collection endpoint for this Azure Monitor Workspace.
-        :param str data_collection_rule_resource_id: The Azure resource Id of the default data collection rule for this Azure Monitor Workspace.
+        Record map for schema in azure monitor.
+        :param str from_: Record Map Key.
+        :param str to: Record Map Value.
         """
-        pulumi.set(__self__, "data_collection_endpoint_resource_id", data_collection_endpoint_resource_id)
-        pulumi.set(__self__, "data_collection_rule_resource_id", data_collection_rule_resource_id)
+        pulumi.set(__self__, "from_", from_)
+        pulumi.set(__self__, "to", to)
 
     @property
-    @pulumi.getter(name="dataCollectionEndpointResourceId")
-    def data_collection_endpoint_resource_id(self) -> str:
+    @pulumi.getter(name="from")
+    def from_(self) -> str:
         """
-        The Azure resource Id of the default data collection endpoint for this Azure Monitor Workspace.
+        Record Map Key.
         """
-        return pulumi.get(self, "data_collection_endpoint_resource_id")
+        return pulumi.get(self, "from_")
 
     @property
-    @pulumi.getter(name="dataCollectionRuleResourceId")
-    def data_collection_rule_resource_id(self) -> str:
+    @pulumi.getter
+    def to(self) -> str:
         """
-        The Azure resource Id of the default data collection rule for this Azure Monitor Workspace.
+        Record Map Value.
         """
-        return pulumi.get(self, "data_collection_rule_resource_id")
+        return pulumi.get(self, "to")
 
 
 @pulumi.output_type
-class AzureMonitorWorkspaceResponseMetrics(dict):
+class ResourceMapResponse(dict):
     """
-    Properties related to the metrics container in the Azure Monitor Workspace
+    Resource map for schema in azure monitor.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "internalId":
-            suggest = "internal_id"
-        elif key == "prometheusQueryEndpoint":
-            suggest = "prometheus_query_endpoint"
+        if key == "from":
+            suggest = "from_"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureMonitorWorkspaceResponseMetrics. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ResourceMapResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        AzureMonitorWorkspaceResponseMetrics.__key_warning(key)
+        ResourceMapResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        AzureMonitorWorkspaceResponseMetrics.__key_warning(key)
+        ResourceMapResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 internal_id: str,
-                 prometheus_query_endpoint: str):
+                 from_: str,
+                 to: str):
         """
-        Properties related to the metrics container in the Azure Monitor Workspace
-        :param str internal_id: An internal identifier for the metrics container. Only to be used by the system
-        :param str prometheus_query_endpoint: The Prometheus query endpoint for the Azure Monitor Workspace
+        Resource map for schema in azure monitor.
+        :param str from_: Resource Map Key.
+        :param str to: Resource Map Value.
         """
-        pulumi.set(__self__, "internal_id", internal_id)
-        pulumi.set(__self__, "prometheus_query_endpoint", prometheus_query_endpoint)
+        pulumi.set(__self__, "from_", from_)
+        pulumi.set(__self__, "to", to)
 
     @property
-    @pulumi.getter(name="internalId")
-    def internal_id(self) -> str:
+    @pulumi.getter(name="from")
+    def from_(self) -> str:
         """
-        An internal identifier for the metrics container. Only to be used by the system
+        Resource Map Key.
         """
-        return pulumi.get(self, "internal_id")
+        return pulumi.get(self, "from_")
 
     @property
-    @pulumi.getter(name="prometheusQueryEndpoint")
-    def prometheus_query_endpoint(self) -> str:
+    @pulumi.getter
+    def to(self) -> str:
         """
-        The Prometheus query endpoint for the Azure Monitor Workspace
+        Resource Map Value.
         """
-        return pulumi.get(self, "prometheus_query_endpoint")
+        return pulumi.get(self, "to")
 
 
 @pulumi.output_type
-class PrivateEndpointConnectionResponse(dict):
+class SchemaMapResponse(dict):
     """
-    The private endpoint connection resource.
+    Schema map for azure monitor for logs.
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "groupIds":
-            suggest = "group_ids"
-        elif key == "privateLinkServiceConnectionState":
-            suggest = "private_link_service_connection_state"
-        elif key == "provisioningState":
-            suggest = "provisioning_state"
-        elif key == "systemData":
-            suggest = "system_data"
-        elif key == "privateEndpoint":
-            suggest = "private_endpoint"
+        if key == "recordMap":
+            suggest = "record_map"
+        elif key == "resourceMap":
+            suggest = "resource_map"
+        elif key == "scopeMap":
+            suggest = "scope_map"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in PrivateEndpointConnectionResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in SchemaMapResponse. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        PrivateEndpointConnectionResponse.__key_warning(key)
+        SchemaMapResponse.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        PrivateEndpointConnectionResponse.__key_warning(key)
+        SchemaMapResponse.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 group_ids: Sequence[str],
-                 id: str,
-                 name: str,
-                 private_link_service_connection_state: 'outputs.PrivateLinkServiceConnectionStateResponse',
-                 provisioning_state: str,
-                 system_data: 'outputs.SystemDataResponse',
-                 type: str,
-                 private_endpoint: Optional['outputs.PrivateEndpointResponse'] = None):
+                 record_map: Sequence['outputs.RecordMapResponse'],
+                 resource_map: Optional[Sequence['outputs.ResourceMapResponse']] = None,
+                 scope_map: Optional[Sequence['outputs.ScopeMapResponse']] = None):
         """
-        The private endpoint connection resource.
-        :param Sequence[str] group_ids: The group ids for the private endpoint resource.
-        :param str id: Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
-        :param str name: The name of the resource
-        :param 'PrivateLinkServiceConnectionStateResponse' private_link_service_connection_state: A collection of information about the state of the connection between service consumer and provider.
-        :param str provisioning_state: The provisioning state of the private endpoint connection resource.
-        :param 'SystemDataResponse' system_data: Azure Resource Manager metadata containing createdBy and modifiedBy information.
-        :param str type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
-        :param 'PrivateEndpointResponse' private_endpoint: The private endpoint resource.
+        Schema map for azure monitor for logs.
+        :param Sequence['RecordMapResponse'] record_map: Record Map.
+        :param Sequence['ResourceMapResponse'] resource_map: Resource Map captures information about the entity for which telemetry is recorded. For example, metrics exposed by a Kubernetes container can be linked to a resource that specifies the cluster, namespace, pod, and container name.Resource may capture an entire hierarchy of entity identification. It may describe the host in the cloud and specific container or an application running in the process.
+        :param Sequence['ScopeMapResponse'] scope_map: A scope map is a logical unit of the application code with which the emitted telemetry can be associated.
         """
-        pulumi.set(__self__, "group_ids", group_ids)
-        pulumi.set(__self__, "id", id)
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)
-        pulumi.set(__self__, "provisioning_state", provisioning_state)
-        pulumi.set(__self__, "system_data", system_data)
-        pulumi.set(__self__, "type", type)
-        if private_endpoint is not None:
-            pulumi.set(__self__, "private_endpoint", private_endpoint)
+        pulumi.set(__self__, "record_map", record_map)
+        if resource_map is not None:
+            pulumi.set(__self__, "resource_map", resource_map)
+        if scope_map is not None:
+            pulumi.set(__self__, "scope_map", scope_map)
 
     @property
-    @pulumi.getter(name="groupIds")
-    def group_ids(self) -> Sequence[str]:
+    @pulumi.getter(name="recordMap")
+    def record_map(self) -> Sequence['outputs.RecordMapResponse']:
         """
-        The group ids for the private endpoint resource.
+        Record Map.
         """
-        return pulumi.get(self, "group_ids")
+        return pulumi.get(self, "record_map")
 
     @property
-    @pulumi.getter
-    def id(self) -> str:
+    @pulumi.getter(name="resourceMap")
+    def resource_map(self) -> Optional[Sequence['outputs.ResourceMapResponse']]:
         """
-        Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
+        Resource Map captures information about the entity for which telemetry is recorded. For example, metrics exposed by a Kubernetes container can be linked to a resource that specifies the cluster, namespace, pod, and container name.Resource may capture an entire hierarchy of entity identification. It may describe the host in the cloud and specific container or an application running in the process.
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "resource_map")
 
     @property
-    @pulumi.getter
-    def name(self) -> str:
+    @pulumi.getter(name="scopeMap")
+    def scope_map(self) -> Optional[Sequence['outputs.ScopeMapResponse']]:
         """
-        The name of the resource
+        A scope map is a logical unit of the application code with which the emitted telemetry can be associated.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "scope_map")
 
-    @property
-    @pulumi.getter(name="privateLinkServiceConnectionState")
-    def private_link_service_connection_state(self) -> 'outputs.PrivateLinkServiceConnectionStateResponse':
-        """
-        A collection of information about the state of the connection between service consumer and provider.
-        """
-        return pulumi.get(self, "private_link_service_connection_state")
 
-    @property
-    @pulumi.getter(name="provisioningState")
-    def provisioning_state(self) -> str:
-        """
-        The provisioning state of the private endpoint connection resource.
-        """
-        return pulumi.get(self, "provisioning_state")
+@pulumi.output_type
+class ScopeMapResponse(dict):
+    """
+    Scope map for schema in azure monitor.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "from":
+            suggest = "from_"
 
-    @property
-    @pulumi.getter(name="systemData")
-    def system_data(self) -> 'outputs.SystemDataResponse':
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ScopeMapResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ScopeMapResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ScopeMapResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 from_: str,
+                 to: str):
         """
-        Azure Resource Manager metadata containing createdBy and modifiedBy information.
+        Scope map for schema in azure monitor.
+        :param str from_: Scope Map Key.
+        :param str to: Scope Map Value.
         """
-        return pulumi.get(self, "system_data")
+        pulumi.set(__self__, "from_", from_)
+        pulumi.set(__self__, "to", to)
 
     @property
-    @pulumi.getter
-    def type(self) -> str:
+    @pulumi.getter(name="from")
+    def from_(self) -> str:
         """
-        The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
+        Scope Map Key.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "from_")
 
     @property
-    @pulumi.getter(name="privateEndpoint")
-    def private_endpoint(self) -> Optional['outputs.PrivateEndpointResponse']:
+    @pulumi.getter
+    def to(self) -> str:
         """
-        The private endpoint resource.
+        Scope Map Value.
         """
-        return pulumi.get(self, "private_endpoint")
+        return pulumi.get(self, "to")
 
 
 @pulumi.output_type
-class PrivateEndpointResponse(dict):
+class ServiceResponse(dict):
     """
-    The private endpoint resource.
+    Service Info.
     """
     def __init__(__self__, *,
-                 id: str):
+                 pipelines: Sequence['outputs.PipelineResponse'],
+                 persistence: Optional['outputs.PersistenceConfigurationsResponse'] = None):
         """
-        The private endpoint resource.
-        :param str id: The ARM identifier for private endpoint.
+        Service Info.
+        :param Sequence['PipelineResponse'] pipelines: Pipelines belonging to a given pipeline group.
+        :param 'PersistenceConfigurationsResponse' persistence: Persistence options to all pipelines in the instance.
         """
-        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "pipelines", pipelines)
+        if persistence is not None:
+            pulumi.set(__self__, "persistence", persistence)
 
     @property
     @pulumi.getter
-    def id(self) -> str:
+    def pipelines(self) -> Sequence['outputs.PipelineResponse']:
         """
-        The ARM identifier for private endpoint.
+        Pipelines belonging to a given pipeline group.
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "pipelines")
+
+    @property
+    @pulumi.getter
+    def persistence(self) -> Optional['outputs.PersistenceConfigurationsResponse']:
+        """
+        Persistence options to all pipelines in the instance.
+        """
+        return pulumi.get(self, "persistence")
 
 
 @pulumi.output_type
-class PrivateLinkServiceConnectionStateResponse(dict):
+class SyslogReceiverResponse(dict):
     """
-    A collection of information about the state of the connection between service consumer and provider.
+    Base receiver using TCP as transport protocol.
     """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "actionsRequired":
-            suggest = "actions_required"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkServiceConnectionStateResponse. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
-        return super().get(key, default)
-
     def __init__(__self__, *,
-                 actions_required: Optional[str] = None,
-                 description: Optional[str] = None,
-                 status: Optional[str] = None):
-        """
-        A collection of information about the state of the connection between service consumer and provider.
-        :param str actions_required: A message indicating if changes on the service provider require any updates on the consumer.
-        :param str description: The reason for approval/rejection of the connection.
-        :param str status: Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
-        """
-        if actions_required is not None:
-            pulumi.set(__self__, "actions_required", actions_required)
-        if description is not None:
-            pulumi.set(__self__, "description", description)
-        if status is not None:
-            pulumi.set(__self__, "status", status)
-
-    @property
-    @pulumi.getter(name="actionsRequired")
-    def actions_required(self) -> Optional[str]:
+                 endpoint: str,
+                 protocol: Optional[str] = None):
         """
-        A message indicating if changes on the service provider require any updates on the consumer.
+        Base receiver using TCP as transport protocol.
+        :param str endpoint: Syslog receiver endpoint definition. Example: 0.0.0.0:<port>.
+        :param str protocol: Protocol to parse syslog messages. Default rfc3164
         """
-        return pulumi.get(self, "actions_required")
+        pulumi.set(__self__, "endpoint", endpoint)
+        if protocol is None:
+            protocol = 'rfc3164'
+        if protocol is not None:
+            pulumi.set(__self__, "protocol", protocol)
 
     @property
     @pulumi.getter
-    def description(self) -> Optional[str]:
+    def endpoint(self) -> str:
         """
-        The reason for approval/rejection of the connection.
+        Syslog receiver endpoint definition. Example: 0.0.0.0:<port>.
         """
-        return pulumi.get(self, "description")
+        return pulumi.get(self, "endpoint")
 
     @property
     @pulumi.getter
-    def status(self) -> Optional[str]:
+    def protocol(self) -> Optional[str]:
         """
-        Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
+        Protocol to parse syslog messages. Default rfc3164
         """
-        return pulumi.get(self, "status")
+        return pulumi.get(self, "protocol")
 
 
 @pulumi.output_type
@@ -444,3 +1511,92 @@ class SystemDataResponse(dict):
         return pulumi.get(self, "last_modified_by_type")
 
 
+@pulumi.output_type
+class TcpExporterResponse(dict):
+    """
+    Base exporter using TCP as transport protocol.
+    """
+    def __init__(__self__, *,
+                 url: str):
+        """
+        Base exporter using TCP as transport protocol.
+        :param str url: TCP url to export.
+        """
+        pulumi.set(__self__, "url", url)
+
+    @property
+    @pulumi.getter
+    def url(self) -> str:
+        """
+        TCP url to export.
+        """
+        return pulumi.get(self, "url")
+
+
+@pulumi.output_type
+class UdpReceiverResponse(dict):
+    """
+    Receiver using UDP as transport protocol.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "readQueueLength":
+            suggest = "read_queue_length"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UdpReceiverResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UdpReceiverResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UdpReceiverResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 endpoint: str,
+                 encoding: Optional[str] = None,
+                 read_queue_length: Optional[int] = None):
+        """
+        Receiver using UDP as transport protocol.
+        :param str endpoint: TCP endpoint definition. Example: 0.0.0.0:<port>.
+        :param str encoding: The encoding of the stream being received.
+        :param int read_queue_length: Max read queue length.
+        """
+        pulumi.set(__self__, "endpoint", endpoint)
+        if encoding is None:
+            encoding = 'nop'
+        if encoding is not None:
+            pulumi.set(__self__, "encoding", encoding)
+        if read_queue_length is None:
+            read_queue_length = 1000
+        if read_queue_length is not None:
+            pulumi.set(__self__, "read_queue_length", read_queue_length)
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> str:
+        """
+        TCP endpoint definition. Example: 0.0.0.0:<port>.
+        """
+        return pulumi.get(self, "endpoint")
+
+    @property
+    @pulumi.getter
+    def encoding(self) -> Optional[str]:
+        """
+        The encoding of the stream being received.
+        """
+        return pulumi.get(self, "encoding")
+
+    @property
+    @pulumi.getter(name="readQueueLength")
+    def read_queue_length(self) -> Optional[int]:
+        """
+        Max read queue length.
+        """
+        return pulumi.get(self, "read_queue_length")
+
+