pulumi-oci 2.5.0a1722062014__py3-none-any.whl → 2.6.0__py3-none-any.whl

pulumi_oci/networkfirewall/outputs.py

@@ -16,6 +16,9 @@ __all__ = [
     'NetworkFirewallPolicySecurityRuleCondition',
     'NetworkFirewallPolicySecurityRulePosition',
     'NetworkFirewallPolicyServicePortRange',
+    'NetworkFirewallPolicyTunnelInspectionRuleCondition',
+    'NetworkFirewallPolicyTunnelInspectionRulePosition',
+    'NetworkFirewallPolicyTunnelInspectionRuleProfile',
     'NetworkFirewallPolicyUrlListUrl',
     'GetNetworkFirewallPoliciesFilterResult',
     'GetNetworkFirewallPoliciesNetworkFirewallPolicySummaryCollectionResult',
@@ -56,6 +59,15 @@ __all__ = [
     'GetNetworkFirewallPolicyServicesServiceSummaryCollectionResult',
     'GetNetworkFirewallPolicyServicesServiceSummaryCollectionItemResult',
     'GetNetworkFirewallPolicyServicesServiceSummaryCollectionItemPortRangeResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRuleConditionResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulePositionResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRuleProfileResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesFilterResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemConditionResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemPositionResult',
+    'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemProfileResult',
     'GetNetworkFirewallPolicyUrlListUrlResult',
     'GetNetworkFirewallPolicyUrlListsFilterResult',
     'GetNetworkFirewallPolicyUrlListsUrlListSummaryCollectionResult',
@@ -367,6 +379,142 @@ class NetworkFirewallPolicyServicePortRange(dict):
         return pulumi.get(self, "maximum_port")
 
 
+@pulumi.output_type
+class NetworkFirewallPolicyTunnelInspectionRuleCondition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "destinationAddresses":
+            suggest = "destination_addresses"
+        elif key == "sourceAddresses":
+            suggest = "source_addresses"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkFirewallPolicyTunnelInspectionRuleCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkFirewallPolicyTunnelInspectionRuleCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkFirewallPolicyTunnelInspectionRuleCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 destination_addresses: Optional[Sequence[str]] = None,
+                 source_addresses: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] destination_addresses: (Updatable) An array of address list names to be evaluated against the traffic destination address.
+        :param Sequence[str] source_addresses: (Updatable) An array of address list names to be evaluated against the traffic source address.
+        """
+        if destination_addresses is not None:
+            pulumi.set(__self__, "destination_addresses", destination_addresses)
+        if source_addresses is not None:
+            pulumi.set(__self__, "source_addresses", source_addresses)
+
+    @property
+    @pulumi.getter(name="destinationAddresses")
+    def destination_addresses(self) -> Optional[Sequence[str]]:
+        """
+        (Updatable) An array of address list names to be evaluated against the traffic destination address.
+        """
+        return pulumi.get(self, "destination_addresses")
+
+    @property
+    @pulumi.getter(name="sourceAddresses")
+    def source_addresses(self) -> Optional[Sequence[str]]:
+        """
+        (Updatable) An array of address list names to be evaluated against the traffic source address.
+        """
+        return pulumi.get(self, "source_addresses")
+
+
+@pulumi.output_type
+class NetworkFirewallPolicyTunnelInspectionRulePosition(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "afterRule":
+            suggest = "after_rule"
+        elif key == "beforeRule":
+            suggest = "before_rule"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkFirewallPolicyTunnelInspectionRulePosition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkFirewallPolicyTunnelInspectionRulePosition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkFirewallPolicyTunnelInspectionRulePosition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 after_rule: Optional[str] = None,
+                 before_rule: Optional[str] = None):
+        """
+        :param str after_rule: (Updatable) Identifier for rule after which this rule lies.
+        :param str before_rule: (Updatable) Identifier for rule before which this rule lies.
+        """
+        if after_rule is not None:
+            pulumi.set(__self__, "after_rule", after_rule)
+        if before_rule is not None:
+            pulumi.set(__self__, "before_rule", before_rule)
+
+    @property
+    @pulumi.getter(name="afterRule")
+    def after_rule(self) -> Optional[str]:
+        """
+        (Updatable) Identifier for rule after which this rule lies.
+        """
+        return pulumi.get(self, "after_rule")
+
+    @property
+    @pulumi.getter(name="beforeRule")
+    def before_rule(self) -> Optional[str]:
+        """
+        (Updatable) Identifier for rule before which this rule lies.
+        """
+        return pulumi.get(self, "before_rule")
+
+
+@pulumi.output_type
+class NetworkFirewallPolicyTunnelInspectionRuleProfile(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "mustReturnTrafficToSource":
+            suggest = "must_return_traffic_to_source"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkFirewallPolicyTunnelInspectionRuleProfile. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkFirewallPolicyTunnelInspectionRuleProfile.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkFirewallPolicyTunnelInspectionRuleProfile.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 must_return_traffic_to_source: Optional[bool] = None):
+        """
+        :param bool must_return_traffic_to_source: (Updatable) Return scanned VXLAN tunnel traffic to source.
+        """
+        if must_return_traffic_to_source is not None:
+            pulumi.set(__self__, "must_return_traffic_to_source", must_return_traffic_to_source)
+
+    @property
+    @pulumi.getter(name="mustReturnTrafficToSource")
+    def must_return_traffic_to_source(self) -> Optional[bool]:
+        """
+        (Updatable) Return scanned VXLAN tunnel traffic to source.
+        """
+        return pulumi.get(self, "must_return_traffic_to_source")
+
+
 @pulumi.output_type
 class NetworkFirewallPolicyUrlListUrl(dict):
     def __init__(__self__, *,
@@ -2092,6 +2240,315 @@ class GetNetworkFirewallPolicyServicesServiceSummaryCollectionItemPortRangeResul
         return pulumi.get(self, "minimum_port")
 
 
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRuleConditionResult(dict):
+    def __init__(__self__, *,
+                 destination_addresses: Sequence[str],
+                 source_addresses: Sequence[str]):
+        """
+        :param Sequence[str] destination_addresses: An array of address list names to be evaluated against the traffic destination address.
+        :param Sequence[str] source_addresses: An array of address list names to be evaluated against the traffic source address.
+        """
+        pulumi.set(__self__, "destination_addresses", destination_addresses)
+        pulumi.set(__self__, "source_addresses", source_addresses)
+
+    @property
+    @pulumi.getter(name="destinationAddresses")
+    def destination_addresses(self) -> Sequence[str]:
+        """
+        An array of address list names to be evaluated against the traffic destination address.
+        """
+        return pulumi.get(self, "destination_addresses")
+
+    @property
+    @pulumi.getter(name="sourceAddresses")
+    def source_addresses(self) -> Sequence[str]:
+        """
+        An array of address list names to be evaluated against the traffic source address.
+        """
+        return pulumi.get(self, "source_addresses")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulePositionResult(dict):
+    def __init__(__self__, *,
+                 after_rule: str,
+                 before_rule: str):
+        """
+        :param str after_rule: Identifier for rule after which this rule lies.
+        :param str before_rule: Identifier for rule before which this rule lies.
+        """
+        pulumi.set(__self__, "after_rule", after_rule)
+        pulumi.set(__self__, "before_rule", before_rule)
+
+    @property
+    @pulumi.getter(name="afterRule")
+    def after_rule(self) -> str:
+        """
+        Identifier for rule after which this rule lies.
+        """
+        return pulumi.get(self, "after_rule")
+
+    @property
+    @pulumi.getter(name="beforeRule")
+    def before_rule(self) -> str:
+        """
+        Identifier for rule before which this rule lies.
+        """
+        return pulumi.get(self, "before_rule")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRuleProfileResult(dict):
+    def __init__(__self__, *,
+                 must_return_traffic_to_source: bool):
+        """
+        :param bool must_return_traffic_to_source: Return scanned VXLAN tunnel traffic to source.
+        """
+        pulumi.set(__self__, "must_return_traffic_to_source", must_return_traffic_to_source)
+
+    @property
+    @pulumi.getter(name="mustReturnTrafficToSource")
+    def must_return_traffic_to_source(self) -> bool:
+        """
+        Return scanned VXLAN tunnel traffic to source.
+        """
+        return pulumi.get(self, "must_return_traffic_to_source")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesFilterResult(dict):
+    def __init__(__self__, *,
+                 name: str,
+                 values: Sequence[str],
+                 regex: Optional[bool] = None):
+        """
+        :param str name: Name for the Tunnel Inspection Rule, must be unique within the policy.
+        """
+        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) -> str:
+        """
+        Name for the Tunnel Inspection Rule, must be unique within the policy.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def values(self) -> Sequence[str]:
+        return pulumi.get(self, "values")
+
+    @property
+    @pulumi.getter
+    def regex(self) -> Optional[bool]:
+        return pulumi.get(self, "regex")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionResult(dict):
+    def __init__(__self__, *,
+                 items: Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemResult']):
+        pulumi.set(__self__, "items", items)
+
+    @property
+    @pulumi.getter
+    def items(self) -> Sequence['outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemResult']:
+        return pulumi.get(self, "items")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemResult(dict):
+    def __init__(__self__, *,
+                 action: str,
+                 condition: 'outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemConditionResult',
+                 name: str,
+                 network_firewall_policy_id: str,
+                 parent_resource_id: str,
+                 position: 'outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemPositionResult',
+                 priority_order: str,
+                 profile: 'outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemProfileResult',
+                 protocol: str):
+        """
+        :param str action: Types of Inspect Action on the Traffic flow.
+               * INSPECT - Inspect the traffic.
+               * INSPECT_AND_CAPTURE_LOG - Inspect and capture logs for the traffic.
+        :param 'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemConditionArgs' condition: Criteria to evaluate against incoming network traffic. A match occurs when at least one item in the array associated with each specified property corresponds with the relevant aspect of the traffic.
+        :param str name: Name for the Tunnel Inspection Rule, must be unique within the policy.
+        :param str network_firewall_policy_id: Unique Network Firewall Policy identifier
+        :param str parent_resource_id: OCID of the Network Firewall Policy this Tunnel Inspection Rule belongs to.
+        :param 'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemPositionArgs' position: An object which defines the position of the rule.
+        :param str priority_order: The priority order in which this rule should be evaluated
+        :param 'GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemProfileArgs' profile: Vxlan Inspect profile used in Vxlan Tunnel Inspection Rules.
+        :param str protocol: Types of Tunnel Inspection Protocol to be applied on the traffic.
+               * VXLAN - VXLAN Tunnel Inspection Protocol will be applied on the traffic.
+        """
+        pulumi.set(__self__, "action", action)
+        pulumi.set(__self__, "condition", condition)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "network_firewall_policy_id", network_firewall_policy_id)
+        pulumi.set(__self__, "parent_resource_id", parent_resource_id)
+        pulumi.set(__self__, "position", position)
+        pulumi.set(__self__, "priority_order", priority_order)
+        pulumi.set(__self__, "profile", profile)
+        pulumi.set(__self__, "protocol", protocol)
+
+    @property
+    @pulumi.getter
+    def action(self) -> str:
+        """
+        Types of Inspect Action on the Traffic flow.
+        * INSPECT - Inspect the traffic.
+        * INSPECT_AND_CAPTURE_LOG - Inspect and capture logs for the traffic.
+        """
+        return pulumi.get(self, "action")
+
+    @property
+    @pulumi.getter
+    def condition(self) -> 'outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemConditionResult':
+        """
+        Criteria to evaluate against incoming network traffic. A match occurs when at least one item in the array associated with each specified property corresponds with the relevant aspect of the traffic.
+        """
+        return pulumi.get(self, "condition")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        Name for the Tunnel Inspection Rule, must be unique within the policy.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="networkFirewallPolicyId")
+    def network_firewall_policy_id(self) -> str:
+        """
+        Unique Network Firewall Policy identifier
+        """
+        return pulumi.get(self, "network_firewall_policy_id")
+
+    @property
+    @pulumi.getter(name="parentResourceId")
+    def parent_resource_id(self) -> str:
+        """
+        OCID of the Network Firewall Policy this Tunnel Inspection Rule belongs to.
+        """
+        return pulumi.get(self, "parent_resource_id")
+
+    @property
+    @pulumi.getter
+    def position(self) -> 'outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemPositionResult':
+        """
+        An object which defines the position of the rule.
+        """
+        return pulumi.get(self, "position")
+
+    @property
+    @pulumi.getter(name="priorityOrder")
+    def priority_order(self) -> str:
+        """
+        The priority order in which this rule should be evaluated
+        """
+        return pulumi.get(self, "priority_order")
+
+    @property
+    @pulumi.getter
+    def profile(self) -> 'outputs.GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemProfileResult':
+        """
+        Vxlan Inspect profile used in Vxlan Tunnel Inspection Rules.
+        """
+        return pulumi.get(self, "profile")
+
+    @property
+    @pulumi.getter
+    def protocol(self) -> str:
+        """
+        Types of Tunnel Inspection Protocol to be applied on the traffic.
+        * VXLAN - VXLAN Tunnel Inspection Protocol will be applied on the traffic.
+        """
+        return pulumi.get(self, "protocol")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemConditionResult(dict):
+    def __init__(__self__, *,
+                 destination_addresses: Sequence[str],
+                 source_addresses: Sequence[str]):
+        """
+        :param Sequence[str] destination_addresses: An array of address list names to be evaluated against the traffic destination address.
+        :param Sequence[str] source_addresses: An array of address list names to be evaluated against the traffic source address.
+        """
+        pulumi.set(__self__, "destination_addresses", destination_addresses)
+        pulumi.set(__self__, "source_addresses", source_addresses)
+
+    @property
+    @pulumi.getter(name="destinationAddresses")
+    def destination_addresses(self) -> Sequence[str]:
+        """
+        An array of address list names to be evaluated against the traffic destination address.
+        """
+        return pulumi.get(self, "destination_addresses")
+
+    @property
+    @pulumi.getter(name="sourceAddresses")
+    def source_addresses(self) -> Sequence[str]:
+        """
+        An array of address list names to be evaluated against the traffic source address.
+        """
+        return pulumi.get(self, "source_addresses")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemPositionResult(dict):
+    def __init__(__self__, *,
+                 after_rule: str,
+                 before_rule: str):
+        """
+        :param str after_rule: Identifier for rule after which this rule lies.
+        :param str before_rule: Identifier for rule before which this rule lies.
+        """
+        pulumi.set(__self__, "after_rule", after_rule)
+        pulumi.set(__self__, "before_rule", before_rule)
+
+    @property
+    @pulumi.getter(name="afterRule")
+    def after_rule(self) -> str:
+        """
+        Identifier for rule after which this rule lies.
+        """
+        return pulumi.get(self, "after_rule")
+
+    @property
+    @pulumi.getter(name="beforeRule")
+    def before_rule(self) -> str:
+        """
+        Identifier for rule before which this rule lies.
+        """
+        return pulumi.get(self, "before_rule")
+
+
+@pulumi.output_type
+class GetNetworkFirewallPolicyTunnelInspectionRulesTunnelInspectionRuleSummaryCollectionItemProfileResult(dict):
+    def __init__(__self__, *,
+                 must_return_traffic_to_source: bool):
+        """
+        :param bool must_return_traffic_to_source: Return scanned VXLAN tunnel traffic to source.
+        """
+        pulumi.set(__self__, "must_return_traffic_to_source", must_return_traffic_to_source)
+
+    @property
+    @pulumi.getter(name="mustReturnTrafficToSource")
+    def must_return_traffic_to_source(self) -> bool:
+        """
+        Return scanned VXLAN tunnel traffic to source.
+        """
+        return pulumi.get(self, "must_return_traffic_to_source")
+
+
 @pulumi.output_type
 class GetNetworkFirewallPolicyUrlListUrlResult(dict):
     def __init__(__self__, *,

pulumi_oci/osmanagementhub/get_software_source.py

@@ -22,7 +22,7 @@ class GetSoftwareSourceResult:
     """
     A collection of values returned by getSoftwareSource.
     """
-    def __init__(__self__, arch_type=None, availability=None, availability_at_oci=None, checksum_type=None, compartment_id=None, custom_software_source_filters=None, defined_tags=None, description=None, display_name=None, freeform_tags=None, gpg_key_fingerprint=None, gpg_key_id=None, gpg_key_url=None, id=None, is_auto_resolve_dependencies=None, is_automatically_updated=None, is_created_from_package_list=None, is_mandatory_for_autonomous_linux=None, origin_software_source_id=None, os_family=None, package_count=None, packages=None, repo_id=None, size=None, software_source_id=None, software_source_type=None, software_source_version=None, state=None, system_tags=None, time_created=None, url=None, vendor_name=None, vendor_software_sources=None):
+    def __init__(__self__, arch_type=None, availability=None, availability_at_oci=None, checksum_type=None, compartment_id=None, custom_software_source_filters=None, defined_tags=None, description=None, display_name=None, freeform_tags=None, gpg_key_fingerprint=None, gpg_key_id=None, gpg_key_url=None, id=None, is_auto_resolve_dependencies=None, is_automatically_updated=None, is_created_from_package_list=None, is_latest_content_only=None, is_mandatory_for_autonomous_linux=None, origin_software_source_id=None, os_family=None, package_count=None, packages=None, repo_id=None, size=None, software_source_id=None, software_source_type=None, software_source_version=None, state=None, system_tags=None, time_created=None, url=None, vendor_name=None, vendor_software_sources=None):
         if arch_type and not isinstance(arch_type, str):
             raise TypeError("Expected argument 'arch_type' to be a str")
         pulumi.set(__self__, "arch_type", arch_type)
@@ -74,6 +74,9 @@ class GetSoftwareSourceResult:
         if is_created_from_package_list and not isinstance(is_created_from_package_list, bool):
             raise TypeError("Expected argument 'is_created_from_package_list' to be a bool")
         pulumi.set(__self__, "is_created_from_package_list", is_created_from_package_list)
+        if is_latest_content_only and not isinstance(is_latest_content_only, bool):
+            raise TypeError("Expected argument 'is_latest_content_only' to be a bool")
+        pulumi.set(__self__, "is_latest_content_only", is_latest_content_only)
         if is_mandatory_for_autonomous_linux and not isinstance(is_mandatory_for_autonomous_linux, bool):
             raise TypeError("Expected argument 'is_mandatory_for_autonomous_linux' to be a bool")
         pulumi.set(__self__, "is_mandatory_for_autonomous_linux", is_mandatory_for_autonomous_linux)
@@ -259,6 +262,19 @@ class GetSoftwareSourceResult:
         """
         return pulumi.get(self, "is_created_from_package_list")
 
+    @property
+    @pulumi.getter(name="isLatestContentOnly")
+    def is_latest_content_only(self) -> bool:
+        """
+        Indicates whether the software source will include only the latest versions of content from vendor software sources, while accounting for other constraints set in the custom or versioned custom software source (such as a package list or filters).
+        * For a module filter that does not specify a stream, this will include all available streams, and within each stream only the latest version of packages.
+        * For a module filter that does specify a stream, this will include only the latest version of packages for the specified stream.
+        * For a package filter that does not specify a version, this will include only the latest available version of the package.
+        * For a package filter that does specify a version, this will include only the specified version of the package (the isLatestContentOnly attribute is ignored).
+        * For a package list, this will include only the specified version of packages and modules in the list (the isLatestContentOnly attribute is ignored).
+        """
+        return pulumi.get(self, "is_latest_content_only")
+
     @property
     @pulumi.getter(name="isMandatoryForAutonomousLinux")
     def is_mandatory_for_autonomous_linux(self) -> bool:
@@ -408,6 +424,7 @@ class AwaitableGetSoftwareSourceResult(GetSoftwareSourceResult):
             is_auto_resolve_dependencies=self.is_auto_resolve_dependencies,
             is_automatically_updated=self.is_automatically_updated,
             is_created_from_package_list=self.is_created_from_package_list,
+            is_latest_content_only=self.is_latest_content_only,
             is_mandatory_for_autonomous_linux=self.is_mandatory_for_autonomous_linux,
             origin_software_source_id=self.origin_software_source_id,
             os_family=self.os_family,
@@ -468,6 +485,7 @@ def get_software_source(software_source_id: Optional[str] = None,
         is_auto_resolve_dependencies=pulumi.get(__ret__, 'is_auto_resolve_dependencies'),
         is_automatically_updated=pulumi.get(__ret__, 'is_automatically_updated'),
         is_created_from_package_list=pulumi.get(__ret__, 'is_created_from_package_list'),
+        is_latest_content_only=pulumi.get(__ret__, 'is_latest_content_only'),
         is_mandatory_for_autonomous_linux=pulumi.get(__ret__, 'is_mandatory_for_autonomous_linux'),
         origin_software_source_id=pulumi.get(__ret__, 'origin_software_source_id'),
         os_family=pulumi.get(__ret__, 'os_family'),