pulumi-oci 3.1.0a1750143229__py3-none-any.whl → 3.1.0a1751948424__py3-none-any.whl

pulumi_oci/loadbalancer/outputs.py

@@ -131,7 +131,11 @@ class BackendSetBackend(dict):
                
                Example: `false`
         :param builtins.bool drain: (Updatable) Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
-        :param builtins.int max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        :param builtins.int max_connections: (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set or set to 0 then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.
+               
+               If setting maxConnections to some value other than 0 then that value must be greater or equal to 256.
+               
+               Example: `300`
         :param builtins.str name: A friendly name for the backend set. It must be unique and it cannot be changed.
                
                Valid backend set names include only alphanumeric characters, dashes, and underscores. Backend set names cannot contain spaces. Avoid entering confidential information.
@@ -195,7 +199,11 @@ class BackendSetBackend(dict):
     @pulumi.getter(name="maxConnections")
     def max_connections(self) -> Optional[builtins.int]:
         """
-        (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        (Updatable) The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set or set to 0 then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.
+
+        If setting maxConnections to some value other than 0 then that value must be greater or equal to 256.
+
+        Example: `300`
         """
         return pulumi.get(self, "max_connections")
 
@@ -1193,7 +1201,9 @@ class LoadBalancerReservedIp(dict):
                
                Reserved IPs will not be deleted when the Load balancer is deleted. They will be unattached from the Load balancer.
                
-               Example: "ocid1.publicip.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
+               Example: "ocid1.publicip.oc1.phx.unique_ID"
+               
+               IPV6 example: "ocid1.ipv6.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
         """
         if id is not None:
             pulumi.set(__self__, "id", id)
@@ -1210,7 +1220,9 @@ class LoadBalancerReservedIp(dict):
 
         Reserved IPs will not be deleted when the Load balancer is deleted. They will be unattached from the Load balancer.
 
-        Example: "ocid1.publicip.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
+        Example: "ocid1.publicip.oc1.phx.unique_ID"
+
+        IPV6 example: "ocid1.ipv6.oc1.phx.unique_ID" Ocid of the pre-created public IP that should be attached to this load balancer. The public IP will be attached to a private IP. **Note** If public IP resource is present in the config, the pulumi preview will throw `After applying this step and refreshing, the plan was not empty` error, and `private_ip_id` needs to be added as an input argument to the public IP resource block or ignore from its lifecycle as shown in examples to resolve this error.
         """
         return pulumi.get(self, "id")
 
@@ -2191,7 +2203,7 @@ class GetBackendSetsBackendsetResult(dict):
                  ssl_configurations: Sequence['outputs.GetBackendSetsBackendsetSslConfigurationResult'],
                  state: builtins.str):
         """
-        :param builtins.int backend_max_connections: The maximum number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting. If this is not set then the number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting is unlimited.  Example: `300`
+        :param builtins.int backend_max_connections: The maximum number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting. If this is not set or set to 0 then the number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting is unlimited.  Example: `300`
         :param Sequence['GetBackendSetsBackendsetHealthCheckerArgs'] health_checkers: The health check policy configuration. For more information, see [Editing Health Check Policies](https://docs.cloud.oracle.com/iaas/Content/Balance/Tasks/editinghealthcheck.htm).
         :param Sequence['GetBackendSetsBackendsetLbCookieSessionPersistenceConfigurationArgs'] lb_cookie_session_persistence_configurations: The configuration details for implementing load balancer cookie session persistence (LB cookie stickiness).
         :param builtins.str load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend sets to retrieve.
@@ -2216,7 +2228,7 @@ class GetBackendSetsBackendsetResult(dict):
     @pulumi.getter(name="backendMaxConnections")
     def backend_max_connections(self) -> builtins.int:
         """
-        The maximum number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting. If this is not set then the number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting is unlimited.  Example: `300`
+        The maximum number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting. If this is not set or set to 0 then the number of simultaneous connections the load balancer can make to any backend in the backend set unless the backend has its own maxConnections setting is unlimited.  Example: `300`
         """
         return pulumi.get(self, "backend_max_connections")
 
@@ -2307,7 +2319,7 @@ class GetBackendSetsBackendsetBackendResult(dict):
         :param builtins.bool backup: Whether the load balancer should treat this server as a backup unit. If `true`, the load balancer forwards no ingress traffic to this backend server unless all other backend servers not marked as "backup" fail the health check policy.
         :param builtins.bool drain: Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
         :param builtins.str ip_address: The IP address of the backend server.  Example: `10.0.0.3`
-        :param builtins.int max_connections: The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        :param builtins.int max_connections: The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set or set to 0 then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param builtins.str name: A friendly name for the backend set. It must be unique and it cannot be changed.
         :param builtins.bool offline: Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param builtins.int port: The backend server port against which to run the health check. If the port is not specified, the load balancer uses the port information from the `Backend` object.  Example: `8080`
@@ -2350,7 +2362,7 @@ class GetBackendSetsBackendsetBackendResult(dict):
     @pulumi.getter(name="maxConnections")
     def max_connections(self) -> builtins.int:
         """
-        The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set or set to 0 then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         """
         return pulumi.get(self, "max_connections")
 
@@ -2753,7 +2765,7 @@ class GetBackendsBackendResult(dict):
         :param builtins.bool drain: Whether the load balancer should drain this server. Servers marked "drain" receive no new incoming traffic.  Example: `false`
         :param builtins.str ip_address: The IP address of the backend server.  Example: `10.0.0.3`
         :param builtins.str load_balancer_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the load balancer associated with the backend set and servers.
-        :param builtins.int max_connections: The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        :param builtins.int max_connections: The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set or set to 0 then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         :param builtins.str name: A read-only field showing the IP address and port that uniquely identify this backend server in the backend set.  Example: `10.0.0.3:8080`
         :param builtins.bool offline: Whether the load balancer should treat this server as offline. Offline servers receive no incoming traffic.  Example: `false`
         :param builtins.int port: The communication port for the backend server.  Example: `8080`
@@ -2809,7 +2821,7 @@ class GetBackendsBackendResult(dict):
     @pulumi.getter(name="maxConnections")
     def max_connections(self) -> builtins.int:
         """
-        The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
+        The maximum number of simultaneous connections the load balancer can make to the backend. If this is not set or set to 0 then the maximum number of simultaneous connections the load balancer can make to the backend is unlimited.  Example: `300`
         """
         return pulumi.get(self, "max_connections")
 
@@ -3733,6 +3745,7 @@ class GetLoadBalancersLoadBalancerResult(dict):
                  ip_address_details: Sequence['outputs.GetLoadBalancersLoadBalancerIpAddressDetailResult'],
                  ip_addresses: Sequence[builtins.str],
                  ip_mode: builtins.str,
+                 ipv6subnet_cidr: builtins.str,
                  is_delete_protection_enabled: builtins.bool,
                  is_private: builtins.bool,
                  is_request_id_enabled: builtins.bool,
@@ -3775,6 +3788,7 @@ class GetLoadBalancersLoadBalancerResult(dict):
         pulumi.set(__self__, "ip_address_details", ip_address_details)
         pulumi.set(__self__, "ip_addresses", ip_addresses)
         pulumi.set(__self__, "ip_mode", ip_mode)
+        pulumi.set(__self__, "ipv6subnet_cidr", ipv6subnet_cidr)
         pulumi.set(__self__, "is_delete_protection_enabled", is_delete_protection_enabled)
         pulumi.set(__self__, "is_private", is_private)
         pulumi.set(__self__, "is_request_id_enabled", is_request_id_enabled)
@@ -3851,6 +3865,11 @@ class GetLoadBalancersLoadBalancerResult(dict):
     def ip_mode(self) -> builtins.str:
         return pulumi.get(self, "ip_mode")
 
+    @property
+    @pulumi.getter(name="ipv6subnetCidr")
+    def ipv6subnet_cidr(self) -> builtins.str:
+        return pulumi.get(self, "ipv6subnet_cidr")
+
     @property
     @pulumi.getter(name="isDeleteProtectionEnabled")
     def is_delete_protection_enabled(self) -> builtins.bool:

pulumi_oci/loganalytics/__init__.py

@@ -12,6 +12,8 @@ from .get_log_analytics_entities import *
 from .get_log_analytics_entities_summary import *
 from .get_log_analytics_entity import *
 from .get_log_analytics_entity_topology import *
+from .get_log_analytics_entity_type import *
+from .get_log_analytics_entity_types import *
 from .get_log_analytics_log_group import *
 from .get_log_analytics_log_groups import *
 from .get_log_analytics_log_groups_summary import *
@@ -42,6 +44,7 @@ from .get_namespace_template import *
 from .get_namespace_templates import *
 from .get_namespaces import *
 from .log_analytics_entity import *
+from .log_analytics_entity_type import *
 from .log_analytics_import_custom_content import *
 from .log_analytics_log_group import *
 from .log_analytics_object_collection_rule import *

pulumi_oci/loganalytics/_inputs.py

@@ -20,6 +20,8 @@ __all__ = [
     'LogAnalyticsEntityMetadataArgsDict',
     'LogAnalyticsEntityMetadataItemArgs',
     'LogAnalyticsEntityMetadataItemArgsDict',
+    'LogAnalyticsEntityTypePropertyArgs',
+    'LogAnalyticsEntityTypePropertyArgsDict',
     'LogAnalyticsImportCustomContentChangeListArgs',
     'LogAnalyticsImportCustomContentChangeListArgsDict',
     'LogAnalyticsObjectCollectionRuleOverrideArgs',
@@ -58,6 +60,8 @@ __all__ = [
     'GetLogAnalyticsEntitiesFilterArgsDict',
     'GetLogAnalyticsEntityTopologyFilterArgs',
     'GetLogAnalyticsEntityTopologyFilterArgsDict',
+    'GetLogAnalyticsEntityTypesFilterArgs',
+    'GetLogAnalyticsEntityTypesFilterArgsDict',
     'GetLogAnalyticsLogGroupsFilterArgs',
     'GetLogAnalyticsLogGroupsFilterArgsDict',
     'GetLogAnalyticsObjectCollectionRulesFilterArgs',
@@ -188,6 +192,69 @@ class LogAnalyticsEntityMetadataItemArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class LogAnalyticsEntityTypePropertyArgsDict(TypedDict):
+        name: pulumi.Input[builtins.str]
+        """
+        Log analytics entity type property name. 
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        description: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Description for the log analytics entity type property.
+        """
+elif False:
+    LogAnalyticsEntityTypePropertyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LogAnalyticsEntityTypePropertyArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[builtins.str],
+                 description: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] name: Log analytics entity type property name. 
+               
+               
+               ** IMPORTANT **
+               Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        :param pulumi.Input[builtins.str] description: Description for the log analytics entity type property.
+        """
+        pulumi.set(__self__, "name", name)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[builtins.str]:
+        """
+        Log analytics entity type property name. 
+
+
+        ** IMPORTANT **
+        Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Description for the log analytics entity type property.
+        """
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "description", value)
+
+
 if not MYPY:
     class LogAnalyticsImportCustomContentChangeListArgsDict(TypedDict):
         conflict_field_display_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
@@ -1931,6 +1998,62 @@ class GetLogAnalyticsEntityTopologyFilterArgs:
         pulumi.set(self, "regex", value)
 
 
+if not MYPY:
+    class GetLogAnalyticsEntityTypesFilterArgsDict(TypedDict):
+        name: builtins.str
+        """
+        A filter to return only log analytics entity types whose name matches the entire name given. The match is case-insensitive.
+        """
+        values: Sequence[builtins.str]
+        regex: NotRequired[builtins.bool]
+elif False:
+    GetLogAnalyticsEntityTypesFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetLogAnalyticsEntityTypesFilterArgs:
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 values: Sequence[builtins.str],
+                 regex: Optional[builtins.bool] = None):
+        """
+        :param builtins.str name: A filter to return only log analytics entity types whose name matches the entire name given. The match is case-insensitive.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "values", values)
+        if regex is not None:
+            pulumi.set(__self__, "regex", regex)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        A filter to return only log analytics entity types whose name matches the entire name given. The match is case-insensitive.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: builtins.str):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def values(self) -> Sequence[builtins.str]:
+        return pulumi.get(self, "values")
+
+    @values.setter
+    def values(self, value: Sequence[builtins.str]):
+        pulumi.set(self, "values", value)
+
+    @property
+    @pulumi.getter
+    def regex(self) -> Optional[builtins.bool]:
+        return pulumi.get(self, "regex")
+
+    @regex.setter
+    def regex(self, value: Optional[builtins.bool]):
+        pulumi.set(self, "regex", value)
+
+
 if not MYPY:
     class GetLogAnalyticsLogGroupsFilterArgsDict(TypedDict):
         name: builtins.str

pulumi_oci/loganalytics/get_log_analytics_entities.py

@@ -281,6 +281,32 @@ def get_log_analytics_entities(cloud_resource_id: Optional[builtins.str] = None,
 
     Return a list of log analytics entities.
 
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_log_analytics_entities = oci.LogAnalytics.get_log_analytics_entities(compartment_id=compartment_id,
+        namespace=log_analytics_entity_namespace,
+        cloud_resource_id=log_analytics_entity_cloud_resource_id,
+        defined_tag_equals=log_analytics_entity_defined_tag_equals,
+        defined_tag_exists=log_analytics_entity_defined_tag_exists,
+        entity_type_names=log_analytics_entity_entity_type_name,
+        freeform_tag_equals=log_analytics_entity_freeform_tag_equals,
+        freeform_tag_exists=log_analytics_entity_freeform_tag_exists,
+        hostname=log_analytics_entity_hostname,
+        hostname_contains=log_analytics_entity_hostname_contains,
+        is_management_agent_id_null=log_analytics_entity_is_management_agent_id_null,
+        is_show_associated_sources_count=log_analytics_entity_is_show_associated_sources_count,
+        lifecycle_details_contains=log_analytics_entity_lifecycle_details_contains,
+        metadata_equals=log_analytics_entity_metadata_equals,
+        name=log_analytics_entity_name,
+        name_contains=log_analytics_entity_name_contains,
+        source_id=test_source["id"],
+        state=log_analytics_entity_state)
+    ```
+
 
     :param builtins.str cloud_resource_id: A filter to return only log analytics entities whose cloudResourceId matches the cloudResourceId given.
     :param builtins.str compartment_id: The ID of the compartment in which to list resources.
@@ -371,6 +397,32 @@ def get_log_analytics_entities_output(cloud_resource_id: Optional[pulumi.Input[O
 
     Return a list of log analytics entities.
 
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_log_analytics_entities = oci.LogAnalytics.get_log_analytics_entities(compartment_id=compartment_id,
+        namespace=log_analytics_entity_namespace,
+        cloud_resource_id=log_analytics_entity_cloud_resource_id,
+        defined_tag_equals=log_analytics_entity_defined_tag_equals,
+        defined_tag_exists=log_analytics_entity_defined_tag_exists,
+        entity_type_names=log_analytics_entity_entity_type_name,
+        freeform_tag_equals=log_analytics_entity_freeform_tag_equals,
+        freeform_tag_exists=log_analytics_entity_freeform_tag_exists,
+        hostname=log_analytics_entity_hostname,
+        hostname_contains=log_analytics_entity_hostname_contains,
+        is_management_agent_id_null=log_analytics_entity_is_management_agent_id_null,
+        is_show_associated_sources_count=log_analytics_entity_is_show_associated_sources_count,
+        lifecycle_details_contains=log_analytics_entity_lifecycle_details_contains,
+        metadata_equals=log_analytics_entity_metadata_equals,
+        name=log_analytics_entity_name,
+        name_contains=log_analytics_entity_name_contains,
+        source_id=test_source["id"],
+        state=log_analytics_entity_state)
+    ```
+
 
     :param builtins.str cloud_resource_id: A filter to return only log analytics entities whose cloudResourceId matches the cloudResourceId given.
     :param builtins.str compartment_id: The ID of the compartment in which to list resources.

pulumi_oci/loganalytics/get_log_analytics_entity_type.py

@@ -0,0 +1,254 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import builtins
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+from . import outputs
+
+__all__ = [
+    'GetLogAnalyticsEntityTypeResult',
+    'AwaitableGetLogAnalyticsEntityTypeResult',
+    'get_log_analytics_entity_type',
+    'get_log_analytics_entity_type_output',
+]
+
+@pulumi.output_type
+class GetLogAnalyticsEntityTypeResult:
+    """
+    A collection of values returned by getLogAnalyticsEntityType.
+    """
+    def __init__(__self__, category=None, cloud_type=None, entity_type_name=None, id=None, internal_name=None, management_agent_eligibility_status=None, name=None, namespace=None, properties=None, state=None, time_created=None, time_updated=None):
+        if category and not isinstance(category, str):
+            raise TypeError("Expected argument 'category' to be a str")
+        pulumi.set(__self__, "category", category)
+        if cloud_type and not isinstance(cloud_type, str):
+            raise TypeError("Expected argument 'cloud_type' to be a str")
+        pulumi.set(__self__, "cloud_type", cloud_type)
+        if entity_type_name and not isinstance(entity_type_name, str):
+            raise TypeError("Expected argument 'entity_type_name' to be a str")
+        pulumi.set(__self__, "entity_type_name", entity_type_name)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if internal_name and not isinstance(internal_name, str):
+            raise TypeError("Expected argument 'internal_name' to be a str")
+        pulumi.set(__self__, "internal_name", internal_name)
+        if management_agent_eligibility_status and not isinstance(management_agent_eligibility_status, str):
+            raise TypeError("Expected argument 'management_agent_eligibility_status' to be a str")
+        pulumi.set(__self__, "management_agent_eligibility_status", management_agent_eligibility_status)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if namespace and not isinstance(namespace, str):
+            raise TypeError("Expected argument 'namespace' to be a str")
+        pulumi.set(__self__, "namespace", namespace)
+        if properties and not isinstance(properties, list):
+            raise TypeError("Expected argument 'properties' to be a list")
+        pulumi.set(__self__, "properties", properties)
+        if state and not isinstance(state, str):
+            raise TypeError("Expected argument 'state' to be a str")
+        pulumi.set(__self__, "state", state)
+        if time_created and not isinstance(time_created, str):
+            raise TypeError("Expected argument 'time_created' to be a str")
+        pulumi.set(__self__, "time_created", time_created)
+        if time_updated and not isinstance(time_updated, str):
+            raise TypeError("Expected argument 'time_updated' to be a str")
+        pulumi.set(__self__, "time_updated", time_updated)
+
+    @property
+    @pulumi.getter
+    def category(self) -> builtins.str:
+        """
+        Log analytics entity type category. Category will be used for grouping and filtering.
+        """
+        return pulumi.get(self, "category")
+
+    @property
+    @pulumi.getter(name="cloudType")
+    def cloud_type(self) -> builtins.str:
+        """
+        Log analytics entity type group. That can be CLOUD (OCI) or NON_CLOUD otherwise.
+        """
+        return pulumi.get(self, "cloud_type")
+
+    @property
+    @pulumi.getter(name="entityTypeName")
+    def entity_type_name(self) -> builtins.str:
+        return pulumi.get(self, "entity_type_name")
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="internalName")
+    def internal_name(self) -> builtins.str:
+        """
+        Internal name for the log analytics entity type.
+        """
+        return pulumi.get(self, "internal_name")
+
+    @property
+    @pulumi.getter(name="managementAgentEligibilityStatus")
+    def management_agent_eligibility_status(self) -> builtins.str:
+        return pulumi.get(self, "management_agent_eligibility_status")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Log analytics entity type property name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> builtins.str:
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter
+    def properties(self) -> Sequence['outputs.GetLogAnalyticsEntityTypePropertyResult']:
+        """
+        The parameters used in file patterns specified in log sources for this log analytics entity type.
+        """
+        return pulumi.get(self, "properties")
+
+    @property
+    @pulumi.getter
+    def state(self) -> builtins.str:
+        """
+        The current lifecycle state of the log analytics entity type.
+        """
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="timeCreated")
+    def time_created(self) -> builtins.str:
+        """
+        Time the log analytics entity type was created. An RFC3339 formatted datetime string.
+        """
+        return pulumi.get(self, "time_created")
+
+    @property
+    @pulumi.getter(name="timeUpdated")
+    def time_updated(self) -> builtins.str:
+        """
+        Time the log analytics entity type was updated. An RFC3339 formatted datetime string.
+        """
+        return pulumi.get(self, "time_updated")
+
+
+class AwaitableGetLogAnalyticsEntityTypeResult(GetLogAnalyticsEntityTypeResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetLogAnalyticsEntityTypeResult(
+            category=self.category,
+            cloud_type=self.cloud_type,
+            entity_type_name=self.entity_type_name,
+            id=self.id,
+            internal_name=self.internal_name,
+            management_agent_eligibility_status=self.management_agent_eligibility_status,
+            name=self.name,
+            namespace=self.namespace,
+            properties=self.properties,
+            state=self.state,
+            time_created=self.time_created,
+            time_updated=self.time_updated)
+
+
+def get_log_analytics_entity_type(entity_type_name: Optional[builtins.str] = None,
+                                  namespace: Optional[builtins.str] = None,
+                                  opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLogAnalyticsEntityTypeResult:
+    """
+    This data source provides details about a specific Log Analytics Entity Type resource in Oracle Cloud Infrastructure Log Analytics service.
+
+    Retrieve the log analytics entity type with the given name.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_log_analytics_entity_type = oci.LogAnalytics.get_log_analytics_entity_type(entity_type_name=log_analytics_entity_type_name,
+        namespace=log_analytics_entity_type_namespace)
+    ```
+
+
+    :param builtins.str entity_type_name: Log analytics entity type name.
+    :param builtins.str namespace: The Logging Analytics namespace used for the request.
+    """
+    __args__ = dict()
+    __args__['entityTypeName'] = entity_type_name
+    __args__['namespace'] = namespace
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('oci:LogAnalytics/getLogAnalyticsEntityType:getLogAnalyticsEntityType', __args__, opts=opts, typ=GetLogAnalyticsEntityTypeResult).value
+
+    return AwaitableGetLogAnalyticsEntityTypeResult(
+        category=pulumi.get(__ret__, 'category'),
+        cloud_type=pulumi.get(__ret__, 'cloud_type'),
+        entity_type_name=pulumi.get(__ret__, 'entity_type_name'),
+        id=pulumi.get(__ret__, 'id'),
+        internal_name=pulumi.get(__ret__, 'internal_name'),
+        management_agent_eligibility_status=pulumi.get(__ret__, 'management_agent_eligibility_status'),
+        name=pulumi.get(__ret__, 'name'),
+        namespace=pulumi.get(__ret__, 'namespace'),
+        properties=pulumi.get(__ret__, 'properties'),
+        state=pulumi.get(__ret__, 'state'),
+        time_created=pulumi.get(__ret__, 'time_created'),
+        time_updated=pulumi.get(__ret__, 'time_updated'))
+def get_log_analytics_entity_type_output(entity_type_name: Optional[pulumi.Input[builtins.str]] = None,
+                                         namespace: Optional[pulumi.Input[builtins.str]] = None,
+                                         opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLogAnalyticsEntityTypeResult]:
+    """
+    This data source provides details about a specific Log Analytics Entity Type resource in Oracle Cloud Infrastructure Log Analytics service.
+
+    Retrieve the log analytics entity type with the given name.
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_oci as oci
+
+    test_log_analytics_entity_type = oci.LogAnalytics.get_log_analytics_entity_type(entity_type_name=log_analytics_entity_type_name,
+        namespace=log_analytics_entity_type_namespace)
+    ```
+
+
+    :param builtins.str entity_type_name: Log analytics entity type name.
+    :param builtins.str namespace: The Logging Analytics namespace used for the request.
+    """
+    __args__ = dict()
+    __args__['entityTypeName'] = entity_type_name
+    __args__['namespace'] = namespace
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('oci:LogAnalytics/getLogAnalyticsEntityType:getLogAnalyticsEntityType', __args__, opts=opts, typ=GetLogAnalyticsEntityTypeResult)
+    return __ret__.apply(lambda __response__: GetLogAnalyticsEntityTypeResult(
+        category=pulumi.get(__response__, 'category'),
+        cloud_type=pulumi.get(__response__, 'cloud_type'),
+        entity_type_name=pulumi.get(__response__, 'entity_type_name'),
+        id=pulumi.get(__response__, 'id'),
+        internal_name=pulumi.get(__response__, 'internal_name'),
+        management_agent_eligibility_status=pulumi.get(__response__, 'management_agent_eligibility_status'),
+        name=pulumi.get(__response__, 'name'),
+        namespace=pulumi.get(__response__, 'namespace'),
+        properties=pulumi.get(__response__, 'properties'),
+        state=pulumi.get(__response__, 'state'),
+        time_created=pulumi.get(__response__, 'time_created'),
+        time_updated=pulumi.get(__response__, 'time_updated')))