# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'BucketRetentionRule',
    'BucketRetentionRuleDuration',
    'ObjectLifecyclePolicyRule',
    'ObjectLifecyclePolicyRuleObjectNameFilter',
    'StorageObjectSourceUriDetails',
    'GetBucketRetentionRuleResult',
    'GetBucketRetentionRuleDurationResult',
    'GetBucketSummariesBucketSummaryResult',
    'GetBucketSummariesBucketSummaryRetentionRuleResult',
    'GetBucketSummariesBucketSummaryRetentionRuleDurationResult',
    'GetBucketSummariesFilterResult',
    'GetObjectLifecyclePolicyRuleResult',
    'GetObjectLifecyclePolicyRuleObjectNameFilterResult',
    'GetObjectVersionsFilterResult',
    'GetObjectVersionsItemResult',
    'GetObjectsFilterResult',
    'GetObjectsObjectResult',
    'GetPreauthrequestsFilterResult',
    'GetPreauthrequestsPreauthenticatedRequestResult',
    'GetReplicationPoliciesFilterResult',
    'GetReplicationPoliciesReplicationPolicyResult',
    'GetReplicationSourcesFilterResult',
    'GetReplicationSourcesReplicationSourceResult',
]

@pulumi.output_type
class BucketRetentionRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "displayName":
            suggest = "display_name"
        elif key == "retentionRuleId":
            suggest = "retention_rule_id"
        elif key == "timeCreated":
            suggest = "time_created"
        elif key == "timeModified":
            suggest = "time_modified"
        elif key == "timeRuleLocked":
            suggest = "time_rule_locked"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BucketRetentionRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BucketRetentionRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BucketRetentionRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 display_name: str,
                 duration: Optional['outputs.BucketRetentionRuleDuration'] = None,
                 retention_rule_id: Optional[str] = None,
                 time_created: Optional[str] = None,
                 time_modified: Optional[str] = None,
                 time_rule_locked: Optional[str] = None):
        """
        :param str display_name: A user-specified name for the retention rule. Names can be helpful in identifying retention rules. The name should be unique. This attribute is a forcenew attribute
        :param 'BucketRetentionRuleDurationArgs' duration: (Updatable)
        :param str retention_rule_id: Unique identifier for the retention rule.
        :param str time_created: The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        :param str time_modified: The date and time that the retention rule was modified as per [RFC3339](https://tools.ietf.org/html/rfc3339).
        :param str time_rule_locked: (Updatable) The date and time as per [RFC 3339](https://tools.ietf.org/html/rfc3339) after which this rule is locked and can only be deleted by deleting the bucket. Once a rule is locked, only increases in the duration are allowed and no other properties can be changed. This property cannot be updated for rules that are in a locked state. Specifying it when a duration is not specified is considered an error.
        """
        pulumi.set(__self__, "display_name", display_name)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if retention_rule_id is not None:
            pulumi.set(__self__, "retention_rule_id", retention_rule_id)
        if time_created is not None:
            pulumi.set(__self__, "time_created", time_created)
        if time_modified is not None:
            pulumi.set(__self__, "time_modified", time_modified)
        if time_rule_locked is not None:
            pulumi.set(__self__, "time_rule_locked", time_rule_locked)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        A user-specified name for the retention rule. Names can be helpful in identifying retention rules. The name should be unique. This attribute is a forcenew attribute
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def duration(self) -> Optional['outputs.BucketRetentionRuleDuration']:
        """
        (Updatable)
        """
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter(name="retentionRuleId")
    def retention_rule_id(self) -> Optional[str]:
        """
        Unique identifier for the retention rule.
        """
        return pulumi.get(self, "retention_rule_id")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> Optional[str]:
        """
        The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeModified")
    def time_modified(self) -> Optional[str]:
        """
        The date and time that the retention rule was modified as per [RFC3339](https://tools.ietf.org/html/rfc3339).
        """
        return pulumi.get(self, "time_modified")

    @property
    @pulumi.getter(name="timeRuleLocked")
    def time_rule_locked(self) -> Optional[str]:
        """
        (Updatable) The date and time as per [RFC 3339](https://tools.ietf.org/html/rfc3339) after which this rule is locked and can only be deleted by deleting the bucket. Once a rule is locked, only increases in the duration are allowed and no other properties can be changed. This property cannot be updated for rules that are in a locked state. Specifying it when a duration is not specified is considered an error.
        """
        return pulumi.get(self, "time_rule_locked")


@pulumi.output_type
class BucketRetentionRuleDuration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeAmount":
            suggest = "time_amount"
        elif key == "timeUnit":
            suggest = "time_unit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BucketRetentionRuleDuration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BucketRetentionRuleDuration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BucketRetentionRuleDuration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 time_amount: str,
                 time_unit: str):
        """
        :param str time_amount: (Updatable) The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified timestamp.
        :param str time_unit: (Updatable) The unit that should be used to interpret timeAmount.
        """
        pulumi.set(__self__, "time_amount", time_amount)
        pulumi.set(__self__, "time_unit", time_unit)

    @property
    @pulumi.getter(name="timeAmount")
    def time_amount(self) -> str:
        """
        (Updatable) The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified timestamp.
        """
        return pulumi.get(self, "time_amount")

    @property
    @pulumi.getter(name="timeUnit")
    def time_unit(self) -> str:
        """
        (Updatable) The unit that should be used to interpret timeAmount.
        """
        return pulumi.get(self, "time_unit")


@pulumi.output_type
class ObjectLifecyclePolicyRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"
        elif key == "timeAmount":
            suggest = "time_amount"
        elif key == "timeUnit":
            suggest = "time_unit"
        elif key == "objectNameFilter":
            suggest = "object_name_filter"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ObjectLifecyclePolicyRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ObjectLifecyclePolicyRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ObjectLifecyclePolicyRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action: str,
                 is_enabled: bool,
                 name: str,
                 time_amount: str,
                 time_unit: str,
                 object_name_filter: Optional['outputs.ObjectLifecyclePolicyRuleObjectNameFilter'] = None,
                 target: Optional[str] = None):
        """
        :param str action: (Updatable) The action of the object lifecycle policy rule. Rules using the action 'ARCHIVE' move objects from Standard and InfrequentAccess storage tiers into the [Archive storage tier](https://docs.cloud.oracle.com/iaas/Content/Archive/Concepts/archivestorageoverview.htm). Rules using the action 'INFREQUENT_ACCESS' move objects from Standard storage tier into the Infrequent Access Storage tier. Objects that are already in InfrequentAccess tier or in Archive tier are left untouched. Rules using the action 'DELETE' permanently delete objects from buckets. Rules using 'ABORT' abort the uncommitted multipart-uploads and permanently delete their parts from buckets.
        :param bool is_enabled: (Updatable) A Boolean that determines whether this rule is currently enabled.
        :param str name: (Updatable) The name of the lifecycle rule to be applied.
        :param str time_amount: (Updatable) Specifies the age of objects to apply the rule to. The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified time.
        :param str time_unit: (Updatable) The unit that should be used to interpret timeAmount.  Days are defined as starting and ending at midnight UTC. Years are defined as 365.2425 days long and likewise round up to the next midnight UTC. 
               
               
               ** 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 'ObjectLifecyclePolicyRuleObjectNameFilterArgs' object_name_filter: (Updatable) A filter that compares object names to a set of prefixes or patterns to determine if a rule applies to a given object. The filter can contain include glob patterns, exclude glob patterns and inclusion prefixes. The inclusion prefixes property is kept for backward compatibility. It is recommended to use inclusion patterns instead of prefixes. Exclusions take precedence over inclusions.
        :param str target: (Updatable) The target of the object lifecycle policy rule. The values of target can be either "objects", "multipart-uploads" or "previous-object-versions". This field when declared as "objects" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for objects. This field when declared as "previous-object-versions" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for previous versions of existing objects. This field when declared as "multipart-uploads" is used to specify the ABORT (only) rule for uncommitted multipart-uploads.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "time_amount", time_amount)
        pulumi.set(__self__, "time_unit", time_unit)
        if object_name_filter is not None:
            pulumi.set(__self__, "object_name_filter", object_name_filter)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        (Updatable) The action of the object lifecycle policy rule. Rules using the action 'ARCHIVE' move objects from Standard and InfrequentAccess storage tiers into the [Archive storage tier](https://docs.cloud.oracle.com/iaas/Content/Archive/Concepts/archivestorageoverview.htm). Rules using the action 'INFREQUENT_ACCESS' move objects from Standard storage tier into the Infrequent Access Storage tier. Objects that are already in InfrequentAccess tier or in Archive tier are left untouched. Rules using the action 'DELETE' permanently delete objects from buckets. Rules using 'ABORT' abort the uncommitted multipart-uploads and permanently delete their parts from buckets.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        (Updatable) A Boolean that determines whether this rule is currently enabled.
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Updatable) The name of the lifecycle rule to be applied.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="timeAmount")
    def time_amount(self) -> str:
        """
        (Updatable) Specifies the age of objects to apply the rule to. The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified time.
        """
        return pulumi.get(self, "time_amount")

    @property
    @pulumi.getter(name="timeUnit")
    def time_unit(self) -> str:
        """
        (Updatable) The unit that should be used to interpret timeAmount.  Days are defined as starting and ending at midnight UTC. Years are defined as 365.2425 days long and likewise round up to the next midnight UTC. 


        ** 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, "time_unit")

    @property
    @pulumi.getter(name="objectNameFilter")
    def object_name_filter(self) -> Optional['outputs.ObjectLifecyclePolicyRuleObjectNameFilter']:
        """
        (Updatable) A filter that compares object names to a set of prefixes or patterns to determine if a rule applies to a given object. The filter can contain include glob patterns, exclude glob patterns and inclusion prefixes. The inclusion prefixes property is kept for backward compatibility. It is recommended to use inclusion patterns instead of prefixes. Exclusions take precedence over inclusions.
        """
        return pulumi.get(self, "object_name_filter")

    @property
    @pulumi.getter
    def target(self) -> Optional[str]:
        """
        (Updatable) The target of the object lifecycle policy rule. The values of target can be either "objects", "multipart-uploads" or "previous-object-versions". This field when declared as "objects" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for objects. This field when declared as "previous-object-versions" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for previous versions of existing objects. This field when declared as "multipart-uploads" is used to specify the ABORT (only) rule for uncommitted multipart-uploads.
        """
        return pulumi.get(self, "target")


@pulumi.output_type
class ObjectLifecyclePolicyRuleObjectNameFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exclusionPatterns":
            suggest = "exclusion_patterns"
        elif key == "inclusionPatterns":
            suggest = "inclusion_patterns"
        elif key == "inclusionPrefixes":
            suggest = "inclusion_prefixes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ObjectLifecyclePolicyRuleObjectNameFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ObjectLifecyclePolicyRuleObjectNameFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ObjectLifecyclePolicyRuleObjectNameFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 exclusion_patterns: Optional[Sequence[str]] = None,
                 inclusion_patterns: Optional[Sequence[str]] = None,
                 inclusion_prefixes: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] exclusion_patterns: (Updatable) An array of glob patterns to match the object names to exclude. An empty array is ignored. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.
               
               The special pattern characters have the following meanings:
               
               \\           Escapes the following character
               *           Matches any string of characters. ?           Matches any single character . [...]       Matches a group of characters. A group of characters can be: A set of characters, for example: [Zafg9@]. This matches any character in the brackets. A range of characters, for example: [a-z]. This matches any character in the range. [a-f] is equivalent to [abcdef]. For character ranges only the CHARACTER-CHARACTER pattern is supported. [ab-yz] is not valid [a-mn-z] is not valid Character ranges can not start with ^ or : To include a '-' in the range, make it the first or last character.
        :param Sequence[str] inclusion_patterns: (Updatable) An array of glob patterns to match the object names to include. An empty array includes all objects in the bucket. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.
               
               The special pattern characters have the following meanings:
               
               \\           Escapes the following character
               *           Matches any string of characters. ?           Matches any single character . [...]       Matches a group of characters. A group of characters can be: A set of characters, for example: [Zafg9@]. This matches any character in the brackets. A range of characters, for example: [a-z]. This matches any character in the range. [a-f] is equivalent to [abcdef]. For character ranges only the CHARACTER-CHARACTER pattern is supported. [ab-yz] is not valid [a-mn-z] is not valid Character ranges can not start with ^ or : To include a '-' in the range, make it the first or last character.
        :param Sequence[str] inclusion_prefixes: (Updatable) An array of object name prefixes that the rule will apply to. An empty array means to include all objects.
        """
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)
        if inclusion_prefixes is not None:
            pulumi.set(__self__, "inclusion_prefixes", inclusion_prefixes)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[Sequence[str]]:
        """
        (Updatable) An array of glob patterns to match the object names to exclude. An empty array is ignored. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.

        The special pattern characters have the following meanings:

        \\           Escapes the following character
        *           Matches any string of characters. ?           Matches any single character . [...]       Matches a group of characters. A group of characters can be: A set of characters, for example: [Zafg9@]. This matches any character in the brackets. A range of characters, for example: [a-z]. This matches any character in the range. [a-f] is equivalent to [abcdef]. For character ranges only the CHARACTER-CHARACTER pattern is supported. [ab-yz] is not valid [a-mn-z] is not valid Character ranges can not start with ^ or : To include a '-' in the range, make it the first or last character.
        """
        return pulumi.get(self, "exclusion_patterns")

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[Sequence[str]]:
        """
        (Updatable) An array of glob patterns to match the object names to include. An empty array includes all objects in the bucket. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.

        The special pattern characters have the following meanings:

        \\           Escapes the following character
        *           Matches any string of characters. ?           Matches any single character . [...]       Matches a group of characters. A group of characters can be: A set of characters, for example: [Zafg9@]. This matches any character in the brackets. A range of characters, for example: [a-z]. This matches any character in the range. [a-f] is equivalent to [abcdef]. For character ranges only the CHARACTER-CHARACTER pattern is supported. [ab-yz] is not valid [a-mn-z] is not valid Character ranges can not start with ^ or : To include a '-' in the range, make it the first or last character.
        """
        return pulumi.get(self, "inclusion_patterns")

    @property
    @pulumi.getter(name="inclusionPrefixes")
    def inclusion_prefixes(self) -> Optional[Sequence[str]]:
        """
        (Updatable) An array of object name prefixes that the rule will apply to. An empty array means to include all objects.
        """
        return pulumi.get(self, "inclusion_prefixes")


@pulumi.output_type
class StorageObjectSourceUriDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationObjectIfMatchEtag":
            suggest = "destination_object_if_match_etag"
        elif key == "destinationObjectIfNoneMatchEtag":
            suggest = "destination_object_if_none_match_etag"
        elif key == "sourceObjectIfMatchEtag":
            suggest = "source_object_if_match_etag"
        elif key == "sourceVersionId":
            suggest = "source_version_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StorageObjectSourceUriDetails. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StorageObjectSourceUriDetails.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StorageObjectSourceUriDetails.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket: str,
                 namespace: str,
                 object: str,
                 region: str,
                 destination_object_if_match_etag: Optional[str] = None,
                 destination_object_if_none_match_etag: Optional[str] = None,
                 source_object_if_match_etag: Optional[str] = None,
                 source_version_id: Optional[str] = None):
        """
        :param str bucket: The name of the bucket for the source object.
        :param str namespace: The top-level namespace of the source object.
        :param str object: The name of the source object.
        :param str region: The region of the source object.
        :param str destination_object_if_match_etag: The entity tag to match the target object.
        :param str destination_object_if_none_match_etag: The entity tag to not match the target object.
        :param str source_object_if_match_etag: The entity tag to match the source object.
        :param str source_version_id: The version id of the object to be restored.
               
               
               ** 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
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "object", object)
        pulumi.set(__self__, "region", region)
        if destination_object_if_match_etag is not None:
            pulumi.set(__self__, "destination_object_if_match_etag", destination_object_if_match_etag)
        if destination_object_if_none_match_etag is not None:
            pulumi.set(__self__, "destination_object_if_none_match_etag", destination_object_if_none_match_etag)
        if source_object_if_match_etag is not None:
            pulumi.set(__self__, "source_object_if_match_etag", source_object_if_match_etag)
        if source_version_id is not None:
            pulumi.set(__self__, "source_version_id", source_version_id)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        The name of the bucket for the source object.
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The top-level namespace of the source object.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def object(self) -> str:
        """
        The name of the source object.
        """
        return pulumi.get(self, "object")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        The region of the source object.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="destinationObjectIfMatchEtag")
    def destination_object_if_match_etag(self) -> Optional[str]:
        """
        The entity tag to match the target object.
        """
        return pulumi.get(self, "destination_object_if_match_etag")

    @property
    @pulumi.getter(name="destinationObjectIfNoneMatchEtag")
    def destination_object_if_none_match_etag(self) -> Optional[str]:
        """
        The entity tag to not match the target object.
        """
        return pulumi.get(self, "destination_object_if_none_match_etag")

    @property
    @pulumi.getter(name="sourceObjectIfMatchEtag")
    def source_object_if_match_etag(self) -> Optional[str]:
        """
        The entity tag to match the source object.
        """
        return pulumi.get(self, "source_object_if_match_etag")

    @property
    @pulumi.getter(name="sourceVersionId")
    def source_version_id(self) -> Optional[str]:
        """
        The version id of the object to be restored.


        ** 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, "source_version_id")


@pulumi.output_type
class GetBucketRetentionRuleResult(dict):
    def __init__(__self__, *,
                 display_name: str,
                 durations: Sequence['outputs.GetBucketRetentionRuleDurationResult'],
                 retention_rule_id: str,
                 time_created: str,
                 time_modified: str,
                 time_rule_locked: str):
        """
        :param str display_name: User specified name for the retention rule.
        :param str retention_rule_id: Unique identifier for the retention rule.
        :param str time_created: The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        :param str time_modified: The date and time that the retention rule was modified as per [RFC3339](https://tools.ietf.org/html/rfc3339).
        :param str time_rule_locked: The date and time as per [RFC 3339](https://tools.ietf.org/html/rfc3339) after which this rule becomes locked. and can only be deleted by deleting the bucket.
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "durations", durations)
        pulumi.set(__self__, "retention_rule_id", retention_rule_id)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_modified", time_modified)
        pulumi.set(__self__, "time_rule_locked", time_rule_locked)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        User specified name for the retention rule.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def durations(self) -> Sequence['outputs.GetBucketRetentionRuleDurationResult']:
        return pulumi.get(self, "durations")

    @property
    @pulumi.getter(name="retentionRuleId")
    def retention_rule_id(self) -> str:
        """
        Unique identifier for the retention rule.
        """
        return pulumi.get(self, "retention_rule_id")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeModified")
    def time_modified(self) -> str:
        """
        The date and time that the retention rule was modified as per [RFC3339](https://tools.ietf.org/html/rfc3339).
        """
        return pulumi.get(self, "time_modified")

    @property
    @pulumi.getter(name="timeRuleLocked")
    def time_rule_locked(self) -> str:
        """
        The date and time as per [RFC 3339](https://tools.ietf.org/html/rfc3339) after which this rule becomes locked. and can only be deleted by deleting the bucket.
        """
        return pulumi.get(self, "time_rule_locked")


@pulumi.output_type
class GetBucketRetentionRuleDurationResult(dict):
    def __init__(__self__, *,
                 time_amount: str,
                 time_unit: str):
        """
        :param str time_amount: The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified timestamp.
        :param str time_unit: The unit that should be used to interpret timeAmount.
        """
        pulumi.set(__self__, "time_amount", time_amount)
        pulumi.set(__self__, "time_unit", time_unit)

    @property
    @pulumi.getter(name="timeAmount")
    def time_amount(self) -> str:
        """
        The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified timestamp.
        """
        return pulumi.get(self, "time_amount")

    @property
    @pulumi.getter(name="timeUnit")
    def time_unit(self) -> str:
        """
        The unit that should be used to interpret timeAmount.
        """
        return pulumi.get(self, "time_unit")


@pulumi.output_type
class GetBucketSummariesBucketSummaryResult(dict):
    def __init__(__self__, *,
                 access_type: str,
                 approximate_count: str,
                 approximate_size: str,
                 auto_tiering: str,
                 bucket_id: str,
                 compartment_id: str,
                 created_by: str,
                 defined_tags: Mapping[str, Any],
                 etag: str,
                 freeform_tags: Mapping[str, Any],
                 id: str,
                 is_read_only: bool,
                 kms_key_id: str,
                 metadata: Mapping[str, Any],
                 name: str,
                 namespace: str,
                 object_events_enabled: bool,
                 object_lifecycle_policy_etag: str,
                 replication_enabled: bool,
                 retention_rules: Sequence['outputs.GetBucketSummariesBucketSummaryRetentionRuleResult'],
                 storage_tier: str,
                 time_created: str,
                 versioning: str):
        """
        :param str access_type: The type of public access enabled on this bucket. A bucket is set to `NoPublicAccess` by default, which only allows an authenticated caller to access the bucket and its contents. When `ObjectRead` is enabled on the bucket, public access is allowed for the `GetObject`, `HeadObject`, and `ListObjects` operations. When `ObjectReadWithoutList` is enabled on the bucket, public access is allowed for the `GetObject` and `HeadObject` operations.
        :param str approximate_count: The approximate number of objects in the bucket. Count statistics are reported periodically. You will see a lag between what is displayed and the actual object count.
        :param str approximate_size: The approximate total size in bytes of all objects in the bucket. Size statistics are reported periodically. You will see a lag between what is displayed and the actual size of the bucket.
        :param str auto_tiering: The auto tiering status on the bucket. A bucket is created with auto tiering `Disabled` by default. For auto tiering `InfrequentAccess`, objects are transitioned automatically between the 'Standard' and 'InfrequentAccess' tiers based on the access pattern of the objects.
        :param str compartment_id: The ID of the compartment in which to list buckets.
        :param str created_by: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the user who created the bucket.
        :param Mapping[str, Any] defined_tags: Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Operations.CostCenter": "42"}`
        :param str etag: The entity tag (ETag) for the bucket.
        :param Mapping[str, Any] freeform_tags: Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`
        :param bool is_read_only: Whether or not this bucket is read only. By default, `isReadOnly` is set to `false`. This will be set to 'true' when this bucket is configured as a destination in a replication policy.
        :param str kms_key_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of a master encryption key used to call the Key Management service to generate a data encryption key or to encrypt or decrypt a data encryption key.
        :param Mapping[str, Any] metadata: Arbitrary string keys and values for user-defined metadata.
        :param str name: The name of the bucket. Avoid entering confidential information. Example: my-new-bucket1
        :param str namespace: The Object Storage namespace used for the request.
        :param bool object_events_enabled: Whether or not events are emitted for object state changes in this bucket. By default, `objectEventsEnabled` is set to `false`. Set `objectEventsEnabled` to `true` to emit events for object state changes. For more information about events, see [Overview of Events](https://docs.cloud.oracle.com/iaas/Content/Events/Concepts/eventsoverview.htm).
        :param str object_lifecycle_policy_etag: The entity tag (ETag) for the live object lifecycle policy on the bucket.
        :param bool replication_enabled: Whether or not this bucket is a replication source. By default, `replicationEnabled` is set to `false`. This will be set to 'true' when you create a replication policy for the bucket.
        :param str storage_tier: The storage tier type assigned to the bucket. A bucket is set to `Standard` tier by default, which means objects uploaded or copied to the bucket will be in the standard storage tier. When the `Archive` tier type is set explicitly for a bucket, objects uploaded or copied to the bucket will be stored in archive storage. The `storageTier` property is immutable after bucket is created.
        :param str time_created: The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        :param str versioning: The versioning status on the bucket. A bucket is created with versioning `Disabled` by default. For versioning `Enabled`, objects are protected from overwrites and deletes, by maintaining their version history. When versioning is `Suspended`, the previous versions will still remain but new versions will no longer be created when overwitten or deleted.
        """
        pulumi.set(__self__, "access_type", access_type)
        pulumi.set(__self__, "approximate_count", approximate_count)
        pulumi.set(__self__, "approximate_size", approximate_size)
        pulumi.set(__self__, "auto_tiering", auto_tiering)
        pulumi.set(__self__, "bucket_id", bucket_id)
        pulumi.set(__self__, "compartment_id", compartment_id)
        pulumi.set(__self__, "created_by", created_by)
        pulumi.set(__self__, "defined_tags", defined_tags)
        pulumi.set(__self__, "etag", etag)
        pulumi.set(__self__, "freeform_tags", freeform_tags)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_read_only", is_read_only)
        pulumi.set(__self__, "kms_key_id", kms_key_id)
        pulumi.set(__self__, "metadata", metadata)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "object_events_enabled", object_events_enabled)
        pulumi.set(__self__, "object_lifecycle_policy_etag", object_lifecycle_policy_etag)
        pulumi.set(__self__, "replication_enabled", replication_enabled)
        pulumi.set(__self__, "retention_rules", retention_rules)
        pulumi.set(__self__, "storage_tier", storage_tier)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "versioning", versioning)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> str:
        """
        The type of public access enabled on this bucket. A bucket is set to `NoPublicAccess` by default, which only allows an authenticated caller to access the bucket and its contents. When `ObjectRead` is enabled on the bucket, public access is allowed for the `GetObject`, `HeadObject`, and `ListObjects` operations. When `ObjectReadWithoutList` is enabled on the bucket, public access is allowed for the `GetObject` and `HeadObject` operations.
        """
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="approximateCount")
    def approximate_count(self) -> str:
        """
        The approximate number of objects in the bucket. Count statistics are reported periodically. You will see a lag between what is displayed and the actual object count.
        """
        return pulumi.get(self, "approximate_count")

    @property
    @pulumi.getter(name="approximateSize")
    def approximate_size(self) -> str:
        """
        The approximate total size in bytes of all objects in the bucket. Size statistics are reported periodically. You will see a lag between what is displayed and the actual size of the bucket.
        """
        return pulumi.get(self, "approximate_size")

    @property
    @pulumi.getter(name="autoTiering")
    def auto_tiering(self) -> str:
        """
        The auto tiering status on the bucket. A bucket is created with auto tiering `Disabled` by default. For auto tiering `InfrequentAccess`, objects are transitioned automatically between the 'Standard' and 'InfrequentAccess' tiers based on the access pattern of the objects.
        """
        return pulumi.get(self, "auto_tiering")

    @property
    @pulumi.getter(name="bucketId")
    def bucket_id(self) -> str:
        return pulumi.get(self, "bucket_id")

    @property
    @pulumi.getter(name="compartmentId")
    def compartment_id(self) -> str:
        """
        The ID of the compartment in which to list buckets.
        """
        return pulumi.get(self, "compartment_id")

    @property
    @pulumi.getter(name="createdBy")
    def created_by(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the user who created the bucket.
        """
        return pulumi.get(self, "created_by")

    @property
    @pulumi.getter(name="definedTags")
    def defined_tags(self) -> Mapping[str, Any]:
        """
        Defined tags for this resource. Each key is predefined and scoped to a namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Operations.CostCenter": "42"}`
        """
        return pulumi.get(self, "defined_tags")

    @property
    @pulumi.getter
    def etag(self) -> str:
        """
        The entity tag (ETag) for the bucket.
        """
        return pulumi.get(self, "etag")

    @property
    @pulumi.getter(name="freeformTags")
    def freeform_tags(self) -> Mapping[str, Any]:
        """
        Free-form tags for this resource. Each tag is a simple key-value pair with no predefined name, type, or namespace. For more information, see [Resource Tags](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/resourcetags.htm). Example: `{"Department": "Finance"}`
        """
        return pulumi.get(self, "freeform_tags")

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isReadOnly")
    def is_read_only(self) -> bool:
        """
        Whether or not this bucket is read only. By default, `isReadOnly` is set to `false`. This will be set to 'true' when this bucket is configured as a destination in a replication policy.
        """
        return pulumi.get(self, "is_read_only")

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> str:
        """
        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of a master encryption key used to call the Key Management service to generate a data encryption key or to encrypt or decrypt a data encryption key.
        """
        return pulumi.get(self, "kms_key_id")

    @property
    @pulumi.getter
    def metadata(self) -> Mapping[str, Any]:
        """
        Arbitrary string keys and values for user-defined metadata.
        """
        return pulumi.get(self, "metadata")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the bucket. Avoid entering confidential information. Example: my-new-bucket1
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The Object Storage namespace used for the request.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter(name="objectEventsEnabled")
    def object_events_enabled(self) -> bool:
        """
        Whether or not events are emitted for object state changes in this bucket. By default, `objectEventsEnabled` is set to `false`. Set `objectEventsEnabled` to `true` to emit events for object state changes. For more information about events, see [Overview of Events](https://docs.cloud.oracle.com/iaas/Content/Events/Concepts/eventsoverview.htm).
        """
        return pulumi.get(self, "object_events_enabled")

    @property
    @pulumi.getter(name="objectLifecyclePolicyEtag")
    def object_lifecycle_policy_etag(self) -> str:
        """
        The entity tag (ETag) for the live object lifecycle policy on the bucket.
        """
        return pulumi.get(self, "object_lifecycle_policy_etag")

    @property
    @pulumi.getter(name="replicationEnabled")
    def replication_enabled(self) -> bool:
        """
        Whether or not this bucket is a replication source. By default, `replicationEnabled` is set to `false`. This will be set to 'true' when you create a replication policy for the bucket.
        """
        return pulumi.get(self, "replication_enabled")

    @property
    @pulumi.getter(name="retentionRules")
    def retention_rules(self) -> Sequence['outputs.GetBucketSummariesBucketSummaryRetentionRuleResult']:
        return pulumi.get(self, "retention_rules")

    @property
    @pulumi.getter(name="storageTier")
    def storage_tier(self) -> str:
        """
        The storage tier type assigned to the bucket. A bucket is set to `Standard` tier by default, which means objects uploaded or copied to the bucket will be in the standard storage tier. When the `Archive` tier type is set explicitly for a bucket, objects uploaded or copied to the bucket will be stored in archive storage. The `storageTier` property is immutable after bucket is created.
        """
        return pulumi.get(self, "storage_tier")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter
    def versioning(self) -> str:
        """
        The versioning status on the bucket. A bucket is created with versioning `Disabled` by default. For versioning `Enabled`, objects are protected from overwrites and deletes, by maintaining their version history. When versioning is `Suspended`, the previous versions will still remain but new versions will no longer be created when overwitten or deleted.
        """
        return pulumi.get(self, "versioning")


@pulumi.output_type
class GetBucketSummariesBucketSummaryRetentionRuleResult(dict):
    def __init__(__self__, *,
                 display_name: str,
                 durations: Sequence['outputs.GetBucketSummariesBucketSummaryRetentionRuleDurationResult'],
                 retention_rule_id: str,
                 time_created: str,
                 time_modified: str,
                 time_rule_locked: str):
        """
        :param str time_created: The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "durations", durations)
        pulumi.set(__self__, "retention_rule_id", retention_rule_id)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_modified", time_modified)
        pulumi.set(__self__, "time_rule_locked", time_rule_locked)

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def durations(self) -> Sequence['outputs.GetBucketSummariesBucketSummaryRetentionRuleDurationResult']:
        return pulumi.get(self, "durations")

    @property
    @pulumi.getter(name="retentionRuleId")
    def retention_rule_id(self) -> str:
        return pulumi.get(self, "retention_rule_id")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the bucket was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeModified")
    def time_modified(self) -> str:
        return pulumi.get(self, "time_modified")

    @property
    @pulumi.getter(name="timeRuleLocked")
    def time_rule_locked(self) -> str:
        return pulumi.get(self, "time_rule_locked")


@pulumi.output_type
class GetBucketSummariesBucketSummaryRetentionRuleDurationResult(dict):
    def __init__(__self__, *,
                 time_amount: str,
                 time_unit: str):
        pulumi.set(__self__, "time_amount", time_amount)
        pulumi.set(__self__, "time_unit", time_unit)

    @property
    @pulumi.getter(name="timeAmount")
    def time_amount(self) -> str:
        return pulumi.get(self, "time_amount")

    @property
    @pulumi.getter(name="timeUnit")
    def time_unit(self) -> str:
        return pulumi.get(self, "time_unit")


@pulumi.output_type
class GetBucketSummariesFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: The name of the bucket. Avoid entering confidential information. Example: my-new-bucket1
        """
        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:
        """
        The name of the bucket. Avoid entering confidential information. Example: my-new-bucket1
        """
        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 GetObjectLifecyclePolicyRuleResult(dict):
    def __init__(__self__, *,
                 action: str,
                 is_enabled: bool,
                 name: str,
                 object_name_filters: Sequence['outputs.GetObjectLifecyclePolicyRuleObjectNameFilterResult'],
                 target: str,
                 time_amount: str,
                 time_unit: str):
        """
        :param str action: The action of the object lifecycle policy rule. Rules using the action 'ARCHIVE' move objects from Standard and InfrequentAccess storage tiers into the [Archive storage tier](https://docs.cloud.oracle.com/iaas/Content/Archive/Concepts/archivestorageoverview.htm). Rules using the action 'INFREQUENT_ACCESS' move objects from Standard storage tier into the Infrequent Access Storage tier. Objects that are already in InfrequentAccess tier or in Archive tier are left untouched. Rules using the action 'DELETE' permanently delete objects from buckets. Rules using 'ABORT' abort the uncommitted multipart-uploads and permanently delete their parts from buckets.
        :param bool is_enabled: A Boolean that determines whether this rule is currently enabled.
        :param str name: The name of the lifecycle rule to be applied.
        :param Sequence['GetObjectLifecyclePolicyRuleObjectNameFilterArgs'] object_name_filters: A filter that compares object names to a set of prefixes or patterns to determine if a rule applies to a given object. The filter can contain include glob patterns, exclude glob patterns and inclusion prefixes. The inclusion prefixes property is kept for backward compatibility. It is recommended to use inclusion patterns instead of prefixes. Exclusions take precedence over inclusions.
        :param str target: The target of the object lifecycle policy rule. The values of target can be either "objects", "multipart-uploads" or "previous-object-versions". This field when declared as "objects" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for objects. This field when declared as "previous-object-versions" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for previous versions of existing objects. This field when declared as "multipart-uploads" is used to specify the ABORT (only) rule for uncommitted multipart-uploads.
        :param str time_amount: Specifies the age of objects to apply the rule to. The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified time.
        :param str time_unit: The unit that should be used to interpret timeAmount.  Days are defined as starting and ending at midnight UTC. Years are defined as 365.2425 days long and likewise round up to the next midnight UTC.
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "object_name_filters", object_name_filters)
        pulumi.set(__self__, "target", target)
        pulumi.set(__self__, "time_amount", time_amount)
        pulumi.set(__self__, "time_unit", time_unit)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        The action of the object lifecycle policy rule. Rules using the action 'ARCHIVE' move objects from Standard and InfrequentAccess storage tiers into the [Archive storage tier](https://docs.cloud.oracle.com/iaas/Content/Archive/Concepts/archivestorageoverview.htm). Rules using the action 'INFREQUENT_ACCESS' move objects from Standard storage tier into the Infrequent Access Storage tier. Objects that are already in InfrequentAccess tier or in Archive tier are left untouched. Rules using the action 'DELETE' permanently delete objects from buckets. Rules using 'ABORT' abort the uncommitted multipart-uploads and permanently delete their parts from buckets.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        """
        A Boolean that determines whether this rule is currently enabled.
        """
        return pulumi.get(self, "is_enabled")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the lifecycle rule to be applied.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="objectNameFilters")
    def object_name_filters(self) -> Sequence['outputs.GetObjectLifecyclePolicyRuleObjectNameFilterResult']:
        """
        A filter that compares object names to a set of prefixes or patterns to determine if a rule applies to a given object. The filter can contain include glob patterns, exclude glob patterns and inclusion prefixes. The inclusion prefixes property is kept for backward compatibility. It is recommended to use inclusion patterns instead of prefixes. Exclusions take precedence over inclusions.
        """
        return pulumi.get(self, "object_name_filters")

    @property
    @pulumi.getter
    def target(self) -> str:
        """
        The target of the object lifecycle policy rule. The values of target can be either "objects", "multipart-uploads" or "previous-object-versions". This field when declared as "objects" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for objects. This field when declared as "previous-object-versions" is used to specify ARCHIVE, INFREQUENT_ACCESS or DELETE rule for previous versions of existing objects. This field when declared as "multipart-uploads" is used to specify the ABORT (only) rule for uncommitted multipart-uploads.
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter(name="timeAmount")
    def time_amount(self) -> str:
        """
        Specifies the age of objects to apply the rule to. The timeAmount is interpreted in units defined by the timeUnit parameter, and is calculated in relation to each object's Last-Modified time.
        """
        return pulumi.get(self, "time_amount")

    @property
    @pulumi.getter(name="timeUnit")
    def time_unit(self) -> str:
        """
        The unit that should be used to interpret timeAmount.  Days are defined as starting and ending at midnight UTC. Years are defined as 365.2425 days long and likewise round up to the next midnight UTC.
        """
        return pulumi.get(self, "time_unit")


@pulumi.output_type
class GetObjectLifecyclePolicyRuleObjectNameFilterResult(dict):
    def __init__(__self__, *,
                 exclusion_patterns: Sequence[str],
                 inclusion_patterns: Sequence[str],
                 inclusion_prefixes: Sequence[str]):
        """
        :param Sequence[str] exclusion_patterns: An array of glob patterns to match the object names to exclude. An empty array is ignored. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.
        :param Sequence[str] inclusion_patterns: An array of glob patterns to match the object names to include. An empty array includes all objects in the bucket. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.
        :param Sequence[str] inclusion_prefixes: An array of object name prefixes that the rule will apply to. An empty array means to include all objects.
        """
        pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)
        pulumi.set(__self__, "inclusion_prefixes", inclusion_prefixes)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Sequence[str]:
        """
        An array of glob patterns to match the object names to exclude. An empty array is ignored. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "exclusion_patterns")

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Sequence[str]:
        """
        An array of glob patterns to match the object names to include. An empty array includes all objects in the bucket. Exclusion patterns take precedence over inclusion patterns. A Glob pattern is a sequence of characters to match text. Any character that appears in the pattern, other than the special pattern characters described below, matches itself. Glob patterns must be between 1 and 1024 characters.
        """
        return pulumi.get(self, "inclusion_patterns")

    @property
    @pulumi.getter(name="inclusionPrefixes")
    def inclusion_prefixes(self) -> Sequence[str]:
        """
        An array of object name prefixes that the rule will apply to. An empty array means to include all objects.
        """
        return pulumi.get(self, "inclusion_prefixes")


@pulumi.output_type
class GetObjectVersionsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: The name of the object. Avoid entering confidential information. Example: test/object1.log
        """
        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:
        """
        The name of the object. Avoid entering confidential information. Example: test/object1.log
        """
        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 GetObjectVersionsItemResult(dict):
    def __init__(__self__, *,
                 archival_state: str,
                 etag: str,
                 is_delete_marker: bool,
                 md5: str,
                 name: str,
                 size: str,
                 storage_tier: str,
                 time_created: str,
                 time_modified: str,
                 version_id: str):
        """
        :param str archival_state: Archival state of an object. This field is set only for objects in Archive tier.
        :param str etag: The current entity tag (ETag) for the object.
        :param bool is_delete_marker: This flag will indicate if the version is deleted or not.
        :param str md5: Base64-encoded MD5 hash of the object data.
        :param str name: The name of the object. Avoid entering confidential information. Example: test/object1.log
        :param str size: Size of the object in bytes.
        :param str storage_tier: The storage tier that the object is stored in.
        :param str time_created: The date and time the object was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        :param str time_modified: The date and time the object was modified, as described in [RFC 2616](https://tools.ietf.org/rfc/rfc2616#section-14.29).
        :param str version_id: VersionId of the object.
        """
        pulumi.set(__self__, "archival_state", archival_state)
        pulumi.set(__self__, "etag", etag)
        pulumi.set(__self__, "is_delete_marker", is_delete_marker)
        pulumi.set(__self__, "md5", md5)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "storage_tier", storage_tier)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_modified", time_modified)
        pulumi.set(__self__, "version_id", version_id)

    @property
    @pulumi.getter(name="archivalState")
    def archival_state(self) -> str:
        """
        Archival state of an object. This field is set only for objects in Archive tier.
        """
        return pulumi.get(self, "archival_state")

    @property
    @pulumi.getter
    def etag(self) -> str:
        """
        The current entity tag (ETag) for the object.
        """
        return pulumi.get(self, "etag")

    @property
    @pulumi.getter(name="isDeleteMarker")
    def is_delete_marker(self) -> bool:
        """
        This flag will indicate if the version is deleted or not.
        """
        return pulumi.get(self, "is_delete_marker")

    @property
    @pulumi.getter
    def md5(self) -> str:
        """
        Base64-encoded MD5 hash of the object data.
        """
        return pulumi.get(self, "md5")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the object. Avoid entering confidential information. Example: test/object1.log
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Size of the object in bytes.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="storageTier")
    def storage_tier(self) -> str:
        """
        The storage tier that the object is stored in.
        """
        return pulumi.get(self, "storage_tier")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the object was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeModified")
    def time_modified(self) -> str:
        """
        The date and time the object was modified, as described in [RFC 2616](https://tools.ietf.org/rfc/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_modified")

    @property
    @pulumi.getter(name="versionId")
    def version_id(self) -> str:
        """
        VersionId of the object.
        """
        return pulumi.get(self, "version_id")


@pulumi.output_type
class GetObjectsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: The name of the object.
        """
        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:
        """
        The name of the object.
        """
        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 GetObjectsObjectResult(dict):
    def __init__(__self__, *,
                 archival_state: str,
                 etag: str,
                 md5: str,
                 name: str,
                 size: str,
                 storage_tier: str,
                 time_created: str,
                 time_modified: str):
        """
        :param str etag: The current entity tag (ETag) for the object.
        :param str md5: Base64-encoded MD5 hash of the object data.
        :param str name: The name of the object.
        :param str size: Size of the object in bytes.
        :param str storage_tier: The storage tier that the object is stored in.
               * `archival-state` - Archival state of an object. This field is set only for objects in Archive tier.
        :param str time_created: The date and time the object was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        :param str time_modified: The date and time the object was modified, as described in [RFC 2616](https://tools.ietf.org/rfc/rfc2616#section-14.29).
        """
        pulumi.set(__self__, "archival_state", archival_state)
        pulumi.set(__self__, "etag", etag)
        pulumi.set(__self__, "md5", md5)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "storage_tier", storage_tier)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_modified", time_modified)

    @property
    @pulumi.getter(name="archivalState")
    def archival_state(self) -> str:
        return pulumi.get(self, "archival_state")

    @property
    @pulumi.getter
    def etag(self) -> str:
        """
        The current entity tag (ETag) for the object.
        """
        return pulumi.get(self, "etag")

    @property
    @pulumi.getter
    def md5(self) -> str:
        """
        Base64-encoded MD5 hash of the object data.
        """
        return pulumi.get(self, "md5")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the object.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Size of the object in bytes.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="storageTier")
    def storage_tier(self) -> str:
        """
        The storage tier that the object is stored in.
        * `archival-state` - Archival state of an object. This field is set only for objects in Archive tier.
        """
        return pulumi.get(self, "storage_tier")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date and time the object was created, as described in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeModified")
    def time_modified(self) -> str:
        """
        The date and time the object was modified, as described in [RFC 2616](https://tools.ietf.org/rfc/rfc2616#section-14.29).
        """
        return pulumi.get(self, "time_modified")


@pulumi.output_type
class GetPreauthrequestsFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: The user-provided name of the pre-authenticated request.
        """
        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:
        """
        The user-provided name of the pre-authenticated request.
        """
        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 GetPreauthrequestsPreauthenticatedRequestResult(dict):
    def __init__(__self__, *,
                 access_type: str,
                 access_uri: str,
                 bucket: str,
                 bucket_listing_action: str,
                 id: str,
                 name: str,
                 namespace: str,
                 object: str,
                 object_name: str,
                 par_id: str,
                 time_created: str,
                 time_expires: str):
        """
        :param str access_type: The operation that can be performed on this resource.
        :param str access_uri: The URI to embed in the URL when using the pre-authenticated request.
        :param str bucket: The name of the bucket. Avoid entering confidential information. Example: `my-new-bucket1`
        :param str bucket_listing_action: Specifies whether a list operation is allowed on a PAR with accessType "AnyObjectRead" or "AnyObjectReadWrite". Deny: Prevents the user from performing a list operation. ListObjects: Authorizes the user to perform a list operation.
        :param str id: The unique identifier to use when directly addressing the pre-authenticated request.
        :param str name: The user-provided name of the pre-authenticated request.
        :param str namespace: The Object Storage namespace used for the request.
        :param str object: Deprecated. Instead use `object_name`.The name of the object that is being granted access to by the pre-authenticated request. Avoid entering confidential information. The object name can be null and if so, the pre-authenticated request grants access to the entire bucket. Example: test/object1.log
        :param str object_name: The name of the object that is being granted access to by the pre-authenticated request. Avoid entering confidential information. The object name can be null and if so, the pre-authenticated request grants access to the entire bucket. Example: test/object1.log
        :param str time_created: The date when the pre-authenticated request was created as per specification [RFC 3339](https://tools.ietf.org/html/rfc3339).
        :param str time_expires: The expiration date for the pre-authenticated request as per [RFC 3339](https://tools.ietf.org/html/rfc3339). After this date the pre-authenticated request will no longer be valid.
        """
        pulumi.set(__self__, "access_type", access_type)
        pulumi.set(__self__, "access_uri", access_uri)
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "bucket_listing_action", bucket_listing_action)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "object", object)
        pulumi.set(__self__, "object_name", object_name)
        pulumi.set(__self__, "par_id", par_id)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_expires", time_expires)

    @property
    @pulumi.getter(name="accessType")
    def access_type(self) -> str:
        """
        The operation that can be performed on this resource.
        """
        return pulumi.get(self, "access_type")

    @property
    @pulumi.getter(name="accessUri")
    def access_uri(self) -> str:
        """
        The URI to embed in the URL when using the pre-authenticated request.
        """
        return pulumi.get(self, "access_uri")

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        The name of the bucket. Avoid entering confidential information. Example: `my-new-bucket1`
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter(name="bucketListingAction")
    def bucket_listing_action(self) -> str:
        """
        Specifies whether a list operation is allowed on a PAR with accessType "AnyObjectRead" or "AnyObjectReadWrite". Deny: Prevents the user from performing a list operation. ListObjects: Authorizes the user to perform a list operation.
        """
        return pulumi.get(self, "bucket_listing_action")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The unique identifier to use when directly addressing the pre-authenticated request.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The user-provided name of the pre-authenticated request.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The Object Storage namespace used for the request.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def object(self) -> str:
        """
        Deprecated. Instead use `object_name`.The name of the object that is being granted access to by the pre-authenticated request. Avoid entering confidential information. The object name can be null and if so, the pre-authenticated request grants access to the entire bucket. Example: test/object1.log
        """
        return pulumi.get(self, "object")

    @property
    @pulumi.getter(name="objectName")
    def object_name(self) -> str:
        """
        The name of the object that is being granted access to by the pre-authenticated request. Avoid entering confidential information. The object name can be null and if so, the pre-authenticated request grants access to the entire bucket. Example: test/object1.log
        """
        return pulumi.get(self, "object_name")

    @property
    @pulumi.getter(name="parId")
    def par_id(self) -> str:
        return pulumi.get(self, "par_id")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date when the pre-authenticated request was created as per specification [RFC 3339](https://tools.ietf.org/html/rfc3339).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeExpires")
    def time_expires(self) -> str:
        """
        The expiration date for the pre-authenticated request as per [RFC 3339](https://tools.ietf.org/html/rfc3339). After this date the pre-authenticated request will no longer be valid.
        """
        return pulumi.get(self, "time_expires")


@pulumi.output_type
class GetReplicationPoliciesFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        """
        :param str name: The name of 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:
        """
        The name of 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 GetReplicationPoliciesReplicationPolicyResult(dict):
    def __init__(__self__, *,
                 bucket: str,
                 delete_object_in_destination_bucket: str,
                 destination_bucket_name: str,
                 destination_region_name: str,
                 id: str,
                 name: str,
                 namespace: str,
                 status: str,
                 status_message: str,
                 time_created: str,
                 time_last_sync: str):
        """
        :param str bucket: The name of the bucket. Avoid entering confidential information. Example: `my-new-bucket1`
        :param str destination_bucket_name: The bucket to replicate to in the destination region. Replication policy creation does not automatically create a destination bucket. Create the destination bucket before creating the policy.
        :param str destination_region_name: The destination region to replicate to, for example "us-ashburn-1".
        :param str id: The id of the replication policy.
        :param str name: The name of the policy.
        :param str namespace: The Object Storage namespace used for the request.
        :param str status: The replication status of the policy. If the status is CLIENT_ERROR, once the user fixes the issue described in the status message, the status will become ACTIVE.
        :param str status_message: A human-readable description of the status.
        :param str time_created: The date when the replication policy was created as per [RFC 3339](https://tools.ietf.org/html/rfc3339).
        :param str time_last_sync: Changes made to the source bucket before this time has been replicated.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "delete_object_in_destination_bucket", delete_object_in_destination_bucket)
        pulumi.set(__self__, "destination_bucket_name", destination_bucket_name)
        pulumi.set(__self__, "destination_region_name", destination_region_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "status_message", status_message)
        pulumi.set(__self__, "time_created", time_created)
        pulumi.set(__self__, "time_last_sync", time_last_sync)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        The name of the bucket. Avoid entering confidential information. Example: `my-new-bucket1`
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter(name="deleteObjectInDestinationBucket")
    def delete_object_in_destination_bucket(self) -> str:
        return pulumi.get(self, "delete_object_in_destination_bucket")

    @property
    @pulumi.getter(name="destinationBucketName")
    def destination_bucket_name(self) -> str:
        """
        The bucket to replicate to in the destination region. Replication policy creation does not automatically create a destination bucket. Create the destination bucket before creating the policy.
        """
        return pulumi.get(self, "destination_bucket_name")

    @property
    @pulumi.getter(name="destinationRegionName")
    def destination_region_name(self) -> str:
        """
        The destination region to replicate to, for example "us-ashburn-1".
        """
        return pulumi.get(self, "destination_region_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The id of the replication policy.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the policy.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def namespace(self) -> str:
        """
        The Object Storage namespace used for the request.
        """
        return pulumi.get(self, "namespace")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The replication status of the policy. If the status is CLIENT_ERROR, once the user fixes the issue described in the status message, the status will become ACTIVE.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="statusMessage")
    def status_message(self) -> str:
        """
        A human-readable description of the status.
        """
        return pulumi.get(self, "status_message")

    @property
    @pulumi.getter(name="timeCreated")
    def time_created(self) -> str:
        """
        The date when the replication policy was created as per [RFC 3339](https://tools.ietf.org/html/rfc3339).
        """
        return pulumi.get(self, "time_created")

    @property
    @pulumi.getter(name="timeLastSync")
    def time_last_sync(self) -> str:
        """
        Changes made to the source bucket before this time has been replicated.
        """
        return pulumi.get(self, "time_last_sync")


@pulumi.output_type
class GetReplicationSourcesFilterResult(dict):
    def __init__(__self__, *,
                 name: str,
                 values: Sequence[str],
                 regex: Optional[bool] = None):
        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:
        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 GetReplicationSourcesReplicationSourceResult(dict):
    def __init__(__self__, *,
                 policy_name: str,
                 source_bucket_name: str,
                 source_region_name: str):
        """
        :param str policy_name: The name of the policy.
        :param str source_bucket_name: The source bucket replicating data from.
        :param str source_region_name: The source region replicating data from, for example "us-ashburn-1".
        """
        pulumi.set(__self__, "policy_name", policy_name)
        pulumi.set(__self__, "source_bucket_name", source_bucket_name)
        pulumi.set(__self__, "source_region_name", source_region_name)

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> str:
        """
        The name of the policy.
        """
        return pulumi.get(self, "policy_name")

    @property
    @pulumi.getter(name="sourceBucketName")
    def source_bucket_name(self) -> str:
        """
        The source bucket replicating data from.
        """
        return pulumi.get(self, "source_bucket_name")

    @property
    @pulumi.getter(name="sourceRegionName")
    def source_region_name(self) -> str:
        """
        The source region replicating data from, for example "us-ashburn-1".
        """
        return pulumi.get(self, "source_region_name")


