# 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__ = [
    'FusionEnvironmentAdminUserItem',
    'FusionEnvironmentCreateFusionEnvironmentAdminUserDetails',
    'FusionEnvironmentFamilyFamilyMaintenancePolicy',
    'FusionEnvironmentKmsKeyInfo',
    'FusionEnvironmentMaintenancePolicy',
    'FusionEnvironmentMaintenancePolicyQuarterlyUpgradeBeginTime',
    'FusionEnvironmentRefresh',
    'FusionEnvironmentRefreshActivityRefreshIssueDetailsList',
    'FusionEnvironmentRule',
    'FusionEnvironmentRuleCondition',
]

@pulumi.output_type
class FusionEnvironmentAdminUserItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailAddress":
            suggest = "email_address"
        elif key == "firstName":
            suggest = "first_name"
        elif key == "lastName":
            suggest = "last_name"

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

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

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

    def __init__(__self__, *,
                 email_address: Optional[str] = None,
                 first_name: Optional[str] = None,
                 last_name: Optional[str] = None,
                 username: Optional[str] = None):
        """
        :param str email_address: The email address for the administrator.
        :param str first_name: The administrator's first name.
        :param str last_name: The administrator's last name.
        :param str username: The username for the administrator.
               
               
               ** 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
        """
        if email_address is not None:
            pulumi.set(__self__, "email_address", email_address)
        if first_name is not None:
            pulumi.set(__self__, "first_name", first_name)
        if last_name is not None:
            pulumi.set(__self__, "last_name", last_name)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="emailAddress")
    def email_address(self) -> Optional[str]:
        """
        The email address for the administrator.
        """
        return pulumi.get(self, "email_address")

    @property
    @pulumi.getter(name="firstName")
    def first_name(self) -> Optional[str]:
        """
        The administrator's first name.
        """
        return pulumi.get(self, "first_name")

    @property
    @pulumi.getter(name="lastName")
    def last_name(self) -> Optional[str]:
        """
        The administrator's last name.
        """
        return pulumi.get(self, "last_name")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        The username for the administrator.


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


@pulumi.output_type
class FusionEnvironmentCreateFusionEnvironmentAdminUserDetails(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailAddress":
            suggest = "email_address"
        elif key == "firstName":
            suggest = "first_name"
        elif key == "lastName":
            suggest = "last_name"

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

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

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

    def __init__(__self__, *,
                 email_address: str,
                 first_name: str,
                 last_name: str,
                 password: str,
                 username: str):
        """
        :param str email_address: The email address for the administrator.
        :param str first_name: The administrator's first name.
        :param str last_name: The administrator's last name.
        :param str password: The password for the administrator.
        :param str username: The username for the administrator.
        """
        pulumi.set(__self__, "email_address", email_address)
        pulumi.set(__self__, "first_name", first_name)
        pulumi.set(__self__, "last_name", last_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="emailAddress")
    def email_address(self) -> str:
        """
        The email address for the administrator.
        """
        return pulumi.get(self, "email_address")

    @property
    @pulumi.getter(name="firstName")
    def first_name(self) -> str:
        """
        The administrator's first name.
        """
        return pulumi.get(self, "first_name")

    @property
    @pulumi.getter(name="lastName")
    def last_name(self) -> str:
        """
        The administrator's last name.
        """
        return pulumi.get(self, "last_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        """
        The password for the administrator.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        """
        The username for the administrator.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class FusionEnvironmentFamilyFamilyMaintenancePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "concurrentMaintenance":
            suggest = "concurrent_maintenance"
        elif key == "isMonthlyPatchingEnabled":
            suggest = "is_monthly_patching_enabled"
        elif key == "quarterlyUpgradeBeginTimes":
            suggest = "quarterly_upgrade_begin_times"

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

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

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

    def __init__(__self__, *,
                 concurrent_maintenance: Optional[str] = None,
                 is_monthly_patching_enabled: Optional[bool] = None,
                 quarterly_upgrade_begin_times: Optional[str] = None):
        """
        :param str concurrent_maintenance: (Updatable) Option to upgrade both production and non-production environments at the same time. When set to PROD both types of environnments are upgraded on the production schedule. When set to NON_PROD both types of environments are upgraded on the non-production schedule.
        :param bool is_monthly_patching_enabled: (Updatable) When True, monthly patching is enabled for the environment family.
        :param str quarterly_upgrade_begin_times: The quarterly maintenance month group schedule of the Fusion environment family.
        """
        if concurrent_maintenance is not None:
            pulumi.set(__self__, "concurrent_maintenance", concurrent_maintenance)
        if is_monthly_patching_enabled is not None:
            pulumi.set(__self__, "is_monthly_patching_enabled", is_monthly_patching_enabled)
        if quarterly_upgrade_begin_times is not None:
            pulumi.set(__self__, "quarterly_upgrade_begin_times", quarterly_upgrade_begin_times)

    @property
    @pulumi.getter(name="concurrentMaintenance")
    def concurrent_maintenance(self) -> Optional[str]:
        """
        (Updatable) Option to upgrade both production and non-production environments at the same time. When set to PROD both types of environnments are upgraded on the production schedule. When set to NON_PROD both types of environments are upgraded on the non-production schedule.
        """
        return pulumi.get(self, "concurrent_maintenance")

    @property
    @pulumi.getter(name="isMonthlyPatchingEnabled")
    def is_monthly_patching_enabled(self) -> Optional[bool]:
        """
        (Updatable) When True, monthly patching is enabled for the environment family.
        """
        return pulumi.get(self, "is_monthly_patching_enabled")

    @property
    @pulumi.getter(name="quarterlyUpgradeBeginTimes")
    def quarterly_upgrade_begin_times(self) -> Optional[str]:
        """
        The quarterly maintenance month group schedule of the Fusion environment family.
        """
        return pulumi.get(self, "quarterly_upgrade_begin_times")


@pulumi.output_type
class FusionEnvironmentKmsKeyInfo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "activeKeyId":
            suggest = "active_key_id"
        elif key == "activeKeyVersion":
            suggest = "active_key_version"
        elif key == "currentKeyLifecycleState":
            suggest = "current_key_lifecycle_state"
        elif key == "scheduledKeyId":
            suggest = "scheduled_key_id"
        elif key == "scheduledKeyStatus":
            suggest = "scheduled_key_status"
        elif key == "scheduledKeyVersion":
            suggest = "scheduled_key_version"
        elif key == "scheduledLifecycleState":
            suggest = "scheduled_lifecycle_state"

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

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

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

    def __init__(__self__, *,
                 active_key_id: Optional[str] = None,
                 active_key_version: Optional[str] = None,
                 current_key_lifecycle_state: Optional[str] = None,
                 scheduled_key_id: Optional[str] = None,
                 scheduled_key_status: Optional[str] = None,
                 scheduled_key_version: Optional[str] = None,
                 scheduled_lifecycle_state: Optional[str] = None):
        if active_key_id is not None:
            pulumi.set(__self__, "active_key_id", active_key_id)
        if active_key_version is not None:
            pulumi.set(__self__, "active_key_version", active_key_version)
        if current_key_lifecycle_state is not None:
            pulumi.set(__self__, "current_key_lifecycle_state", current_key_lifecycle_state)
        if scheduled_key_id is not None:
            pulumi.set(__self__, "scheduled_key_id", scheduled_key_id)
        if scheduled_key_status is not None:
            pulumi.set(__self__, "scheduled_key_status", scheduled_key_status)
        if scheduled_key_version is not None:
            pulumi.set(__self__, "scheduled_key_version", scheduled_key_version)
        if scheduled_lifecycle_state is not None:
            pulumi.set(__self__, "scheduled_lifecycle_state", scheduled_lifecycle_state)

    @property
    @pulumi.getter(name="activeKeyId")
    def active_key_id(self) -> Optional[str]:
        return pulumi.get(self, "active_key_id")

    @property
    @pulumi.getter(name="activeKeyVersion")
    def active_key_version(self) -> Optional[str]:
        return pulumi.get(self, "active_key_version")

    @property
    @pulumi.getter(name="currentKeyLifecycleState")
    def current_key_lifecycle_state(self) -> Optional[str]:
        return pulumi.get(self, "current_key_lifecycle_state")

    @property
    @pulumi.getter(name="scheduledKeyId")
    def scheduled_key_id(self) -> Optional[str]:
        return pulumi.get(self, "scheduled_key_id")

    @property
    @pulumi.getter(name="scheduledKeyStatus")
    def scheduled_key_status(self) -> Optional[str]:
        return pulumi.get(self, "scheduled_key_status")

    @property
    @pulumi.getter(name="scheduledKeyVersion")
    def scheduled_key_version(self) -> Optional[str]:
        return pulumi.get(self, "scheduled_key_version")

    @property
    @pulumi.getter(name="scheduledLifecycleState")
    def scheduled_lifecycle_state(self) -> Optional[str]:
        return pulumi.get(self, "scheduled_lifecycle_state")


@pulumi.output_type
class FusionEnvironmentMaintenancePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "environmentMaintenanceOverride":
            suggest = "environment_maintenance_override"
        elif key == "monthlyPatchingOverride":
            suggest = "monthly_patching_override"
        elif key == "quarterlyUpgradeBeginTimes":
            suggest = "quarterly_upgrade_begin_times"

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

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

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

    def __init__(__self__, *,
                 environment_maintenance_override: Optional[str] = None,
                 monthly_patching_override: Optional[str] = None,
                 quarterly_upgrade_begin_times: Optional[Sequence['outputs.FusionEnvironmentMaintenancePolicyQuarterlyUpgradeBeginTime']] = None):
        """
        :param str environment_maintenance_override: (Updatable) User choice to upgrade both test and prod pods at the same time. Overrides fusion environment families'.
        :param str monthly_patching_override: (Updatable) When "ENABLED", the Fusion environment is patched monthly. When "DISABLED", the Fusion environment is not patched monthly. This setting overrides the environment family setting. When not set, the environment follows the environment family policy.
        :param Sequence['FusionEnvironmentMaintenancePolicyQuarterlyUpgradeBeginTimeArgs'] quarterly_upgrade_begin_times: Determines the quarterly upgrade begin times (monthly maintenance group schedule ) of the Fusion environment.
        """
        if environment_maintenance_override is not None:
            pulumi.set(__self__, "environment_maintenance_override", environment_maintenance_override)
        if monthly_patching_override is not None:
            pulumi.set(__self__, "monthly_patching_override", monthly_patching_override)
        if quarterly_upgrade_begin_times is not None:
            pulumi.set(__self__, "quarterly_upgrade_begin_times", quarterly_upgrade_begin_times)

    @property
    @pulumi.getter(name="environmentMaintenanceOverride")
    def environment_maintenance_override(self) -> Optional[str]:
        """
        (Updatable) User choice to upgrade both test and prod pods at the same time. Overrides fusion environment families'.
        """
        return pulumi.get(self, "environment_maintenance_override")

    @property
    @pulumi.getter(name="monthlyPatchingOverride")
    def monthly_patching_override(self) -> Optional[str]:
        """
        (Updatable) When "ENABLED", the Fusion environment is patched monthly. When "DISABLED", the Fusion environment is not patched monthly. This setting overrides the environment family setting. When not set, the environment follows the environment family policy.
        """
        return pulumi.get(self, "monthly_patching_override")

    @property
    @pulumi.getter(name="quarterlyUpgradeBeginTimes")
    def quarterly_upgrade_begin_times(self) -> Optional[Sequence['outputs.FusionEnvironmentMaintenancePolicyQuarterlyUpgradeBeginTime']]:
        """
        Determines the quarterly upgrade begin times (monthly maintenance group schedule ) of the Fusion environment.
        """
        return pulumi.get(self, "quarterly_upgrade_begin_times")


@pulumi.output_type
class FusionEnvironmentMaintenancePolicyQuarterlyUpgradeBeginTime(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "beginTimesValue":
            suggest = "begin_times_value"
        elif key == "overrideType":
            suggest = "override_type"

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

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

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

    def __init__(__self__, *,
                 begin_times_value: Optional[str] = None,
                 override_type: Optional[str] = None):
        """
        :param str begin_times_value: The frequency and month when maintenance occurs for the Fusion environment.
        :param str override_type: Determines if the maintenance schedule of the Fusion environment is inherited from the Fusion environment family.
        """
        if begin_times_value is not None:
            pulumi.set(__self__, "begin_times_value", begin_times_value)
        if override_type is not None:
            pulumi.set(__self__, "override_type", override_type)

    @property
    @pulumi.getter(name="beginTimesValue")
    def begin_times_value(self) -> Optional[str]:
        """
        The frequency and month when maintenance occurs for the Fusion environment.
        """
        return pulumi.get(self, "begin_times_value")

    @property
    @pulumi.getter(name="overrideType")
    def override_type(self) -> Optional[str]:
        """
        Determines if the maintenance schedule of the Fusion environment is inherited from the Fusion environment family.
        """
        return pulumi.get(self, "override_type")


@pulumi.output_type
class FusionEnvironmentRefresh(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceFusionEnvironmentId":
            suggest = "source_fusion_environment_id"
        elif key == "timeFinished":
            suggest = "time_finished"
        elif key == "timeOfRestorationPoint":
            suggest = "time_of_restoration_point"

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

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

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

    def __init__(__self__, *,
                 source_fusion_environment_id: Optional[str] = None,
                 time_finished: Optional[str] = None,
                 time_of_restoration_point: Optional[str] = None):
        """
        :param str source_fusion_environment_id: The source environment id for the last refresh
        :param str time_finished: The time of when the last refresh finish
        :param str time_of_restoration_point: The point of time of the latest DB backup for the last refresh
        """
        if source_fusion_environment_id is not None:
            pulumi.set(__self__, "source_fusion_environment_id", source_fusion_environment_id)
        if time_finished is not None:
            pulumi.set(__self__, "time_finished", time_finished)
        if time_of_restoration_point is not None:
            pulumi.set(__self__, "time_of_restoration_point", time_of_restoration_point)

    @property
    @pulumi.getter(name="sourceFusionEnvironmentId")
    def source_fusion_environment_id(self) -> Optional[str]:
        """
        The source environment id for the last refresh
        """
        return pulumi.get(self, "source_fusion_environment_id")

    @property
    @pulumi.getter(name="timeFinished")
    def time_finished(self) -> Optional[str]:
        """
        The time of when the last refresh finish
        """
        return pulumi.get(self, "time_finished")

    @property
    @pulumi.getter(name="timeOfRestorationPoint")
    def time_of_restoration_point(self) -> Optional[str]:
        """
        The point of time of the latest DB backup for the last refresh
        """
        return pulumi.get(self, "time_of_restoration_point")


@pulumi.output_type
class FusionEnvironmentRefreshActivityRefreshIssueDetailsList(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "refreshIssues":
            suggest = "refresh_issues"

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

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

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

    def __init__(__self__, *,
                 refresh_issues: Optional[str] = None):
        """
        :param str refresh_issues: Detail reasons of refresh failure or validation failure that needs to be shown to customer.
        """
        if refresh_issues is not None:
            pulumi.set(__self__, "refresh_issues", refresh_issues)

    @property
    @pulumi.getter(name="refreshIssues")
    def refresh_issues(self) -> Optional[str]:
        """
        Detail reasons of refresh failure or validation failure that needs to be shown to customer.
        """
        return pulumi.get(self, "refresh_issues")


@pulumi.output_type
class FusionEnvironmentRule(dict):
    def __init__(__self__, *,
                 action: str,
                 conditions: Sequence['outputs.FusionEnvironmentRuleCondition'],
                 description: Optional[str] = None):
        """
        :param str action: (Updatable) Rule type
        :param Sequence['FusionEnvironmentRuleConditionArgs'] conditions: (Updatable)
        :param str description: (Updatable) A brief description of the access control rule. Avoid entering confidential information. example: `192.168.0.0/16 and 2001:db8::/32 are trusted clients. Whitelist them.` 
               
               
               ** 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__, "action", action)
        pulumi.set(__self__, "conditions", conditions)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        (Updatable) Rule type
        """
        return pulumi.get(self, "action")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Updatable) A brief description of the access control rule. Avoid entering confidential information. example: `192.168.0.0/16 and 2001:db8::/32 are trusted clients. Whitelist them.` 


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


@pulumi.output_type
class FusionEnvironmentRuleCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attributeName":
            suggest = "attribute_name"
        elif key == "attributeValue":
            suggest = "attribute_value"

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

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

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

    def __init__(__self__, *,
                 attribute_name: str,
                 attribute_value: str):
        """
        :param str attribute_name: (Updatable) RuleCondition type
        :param str attribute_value: (Updatable) The OCID of the originating VCN that an incoming packet must match. You can use this condition in conjunction with `SourceVcnIpAddressCondition`. **NOTE:** If you define this condition for a rule without a `SourceVcnIpAddressCondition`, this condition matches all incoming traffic in the specified VCN.
        """
        pulumi.set(__self__, "attribute_name", attribute_name)
        pulumi.set(__self__, "attribute_value", attribute_value)

    @property
    @pulumi.getter(name="attributeName")
    def attribute_name(self) -> str:
        """
        (Updatable) RuleCondition type
        """
        return pulumi.get(self, "attribute_name")

    @property
    @pulumi.getter(name="attributeValue")
    def attribute_value(self) -> str:
        """
        (Updatable) The OCID of the originating VCN that an incoming packet must match. You can use this condition in conjunction with `SourceVcnIpAddressCondition`. **NOTE:** If you define this condition for a rule without a `SourceVcnIpAddressCondition`, this condition matches all incoming traffic in the specified VCN.
        """
        return pulumi.get(self, "attribute_value")


