# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'LaunchProfileStreamConfigurationArgs',
    'StudioComponentActiveDirectoryComputerAttributeArgs',
    'StudioComponentActiveDirectoryConfigurationArgs',
    'StudioComponentComputeFarmConfigurationArgs',
    'StudioComponentLicenseServiceConfigurationArgs',
    'StudioComponentScriptParameterKeyValueArgs',
    'StudioComponentSharedFileSystemConfigurationArgs',
    'StudioComponentStudioComponentConfigurationArgs',
    'StudioComponentStudioComponentInitializationScriptArgs',
    'StudioStudioEncryptionConfigurationArgs',
]

@pulumi.input_type
class LaunchProfileStreamConfigurationArgs:
    def __init__(__self__, *,
                 clipboard_mode: pulumi.Input[str],
                 ec2_instance_types: pulumi.Input[Sequence[pulumi.Input[str]]],
                 streaming_image_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                 max_session_length_in_minutes: Optional[pulumi.Input[float]] = None):
        pulumi.set(__self__, "clipboard_mode", clipboard_mode)
        pulumi.set(__self__, "ec2_instance_types", ec2_instance_types)
        pulumi.set(__self__, "streaming_image_ids", streaming_image_ids)
        if max_session_length_in_minutes is not None:
            pulumi.set(__self__, "max_session_length_in_minutes", max_session_length_in_minutes)

    @property
    @pulumi.getter(name="clipboardMode")
    def clipboard_mode(self) -> pulumi.Input[str]:
        return pulumi.get(self, "clipboard_mode")

    @clipboard_mode.setter
    def clipboard_mode(self, value: pulumi.Input[str]):
        pulumi.set(self, "clipboard_mode", value)

    @property
    @pulumi.getter(name="ec2InstanceTypes")
    def ec2_instance_types(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "ec2_instance_types")

    @ec2_instance_types.setter
    def ec2_instance_types(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "ec2_instance_types", value)

    @property
    @pulumi.getter(name="streamingImageIds")
    def streaming_image_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "streaming_image_ids")

    @streaming_image_ids.setter
    def streaming_image_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "streaming_image_ids", value)

    @property
    @pulumi.getter(name="maxSessionLengthInMinutes")
    def max_session_length_in_minutes(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "max_session_length_in_minutes")

    @max_session_length_in_minutes.setter
    def max_session_length_in_minutes(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_session_length_in_minutes", value)


@pulumi.input_type
class StudioComponentActiveDirectoryComputerAttributeArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class StudioComponentActiveDirectoryConfigurationArgs:
    def __init__(__self__, *,
                 computer_attributes: Optional[pulumi.Input[Sequence[pulumi.Input['StudioComponentActiveDirectoryComputerAttributeArgs']]]] = None,
                 directory_id: Optional[pulumi.Input[str]] = None,
                 organizational_unit_distinguished_name: Optional[pulumi.Input[str]] = None):
        if computer_attributes is not None:
            pulumi.set(__self__, "computer_attributes", computer_attributes)
        if directory_id is not None:
            pulumi.set(__self__, "directory_id", directory_id)
        if organizational_unit_distinguished_name is not None:
            pulumi.set(__self__, "organizational_unit_distinguished_name", organizational_unit_distinguished_name)

    @property
    @pulumi.getter(name="computerAttributes")
    def computer_attributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StudioComponentActiveDirectoryComputerAttributeArgs']]]]:
        return pulumi.get(self, "computer_attributes")

    @computer_attributes.setter
    def computer_attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StudioComponentActiveDirectoryComputerAttributeArgs']]]]):
        pulumi.set(self, "computer_attributes", value)

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

    @directory_id.setter
    def directory_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "directory_id", value)

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

    @organizational_unit_distinguished_name.setter
    def organizational_unit_distinguished_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "organizational_unit_distinguished_name", value)


@pulumi.input_type
class StudioComponentComputeFarmConfigurationArgs:
    def __init__(__self__, *,
                 active_directory_user: Optional[pulumi.Input[str]] = None,
                 endpoint: Optional[pulumi.Input[str]] = None):
        if active_directory_user is not None:
            pulumi.set(__self__, "active_directory_user", active_directory_user)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)

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

    @active_directory_user.setter
    def active_directory_user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "active_directory_user", value)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)


@pulumi.input_type
class StudioComponentLicenseServiceConfigurationArgs:
    def __init__(__self__, *,
                 endpoint: Optional[pulumi.Input[str]] = None):
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)


@pulumi.input_type
class StudioComponentScriptParameterKeyValueArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class StudioComponentSharedFileSystemConfigurationArgs:
    def __init__(__self__, *,
                 endpoint: Optional[pulumi.Input[str]] = None,
                 file_system_id: Optional[pulumi.Input[str]] = None,
                 linux_mount_point: Optional[pulumi.Input[str]] = None,
                 share_name: Optional[pulumi.Input[str]] = None,
                 windows_mount_drive: Optional[pulumi.Input[str]] = None):
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if file_system_id is not None:
            pulumi.set(__self__, "file_system_id", file_system_id)
        if linux_mount_point is not None:
            pulumi.set(__self__, "linux_mount_point", linux_mount_point)
        if share_name is not None:
            pulumi.set(__self__, "share_name", share_name)
        if windows_mount_drive is not None:
            pulumi.set(__self__, "windows_mount_drive", windows_mount_drive)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "endpoint", value)

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

    @file_system_id.setter
    def file_system_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "file_system_id", value)

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

    @linux_mount_point.setter
    def linux_mount_point(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "linux_mount_point", value)

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

    @share_name.setter
    def share_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "share_name", value)

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

    @windows_mount_drive.setter
    def windows_mount_drive(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "windows_mount_drive", value)


@pulumi.input_type
class StudioComponentStudioComponentConfigurationArgs:
    def __init__(__self__, *,
                 active_directory_configuration: Optional[pulumi.Input['StudioComponentActiveDirectoryConfigurationArgs']] = None,
                 compute_farm_configuration: Optional[pulumi.Input['StudioComponentComputeFarmConfigurationArgs']] = None,
                 license_service_configuration: Optional[pulumi.Input['StudioComponentLicenseServiceConfigurationArgs']] = None,
                 shared_file_system_configuration: Optional[pulumi.Input['StudioComponentSharedFileSystemConfigurationArgs']] = None):
        if active_directory_configuration is not None:
            pulumi.set(__self__, "active_directory_configuration", active_directory_configuration)
        if compute_farm_configuration is not None:
            pulumi.set(__self__, "compute_farm_configuration", compute_farm_configuration)
        if license_service_configuration is not None:
            pulumi.set(__self__, "license_service_configuration", license_service_configuration)
        if shared_file_system_configuration is not None:
            pulumi.set(__self__, "shared_file_system_configuration", shared_file_system_configuration)

    @property
    @pulumi.getter(name="activeDirectoryConfiguration")
    def active_directory_configuration(self) -> Optional[pulumi.Input['StudioComponentActiveDirectoryConfigurationArgs']]:
        return pulumi.get(self, "active_directory_configuration")

    @active_directory_configuration.setter
    def active_directory_configuration(self, value: Optional[pulumi.Input['StudioComponentActiveDirectoryConfigurationArgs']]):
        pulumi.set(self, "active_directory_configuration", value)

    @property
    @pulumi.getter(name="computeFarmConfiguration")
    def compute_farm_configuration(self) -> Optional[pulumi.Input['StudioComponentComputeFarmConfigurationArgs']]:
        return pulumi.get(self, "compute_farm_configuration")

    @compute_farm_configuration.setter
    def compute_farm_configuration(self, value: Optional[pulumi.Input['StudioComponentComputeFarmConfigurationArgs']]):
        pulumi.set(self, "compute_farm_configuration", value)

    @property
    @pulumi.getter(name="licenseServiceConfiguration")
    def license_service_configuration(self) -> Optional[pulumi.Input['StudioComponentLicenseServiceConfigurationArgs']]:
        return pulumi.get(self, "license_service_configuration")

    @license_service_configuration.setter
    def license_service_configuration(self, value: Optional[pulumi.Input['StudioComponentLicenseServiceConfigurationArgs']]):
        pulumi.set(self, "license_service_configuration", value)

    @property
    @pulumi.getter(name="sharedFileSystemConfiguration")
    def shared_file_system_configuration(self) -> Optional[pulumi.Input['StudioComponentSharedFileSystemConfigurationArgs']]:
        return pulumi.get(self, "shared_file_system_configuration")

    @shared_file_system_configuration.setter
    def shared_file_system_configuration(self, value: Optional[pulumi.Input['StudioComponentSharedFileSystemConfigurationArgs']]):
        pulumi.set(self, "shared_file_system_configuration", value)


@pulumi.input_type
class StudioComponentStudioComponentInitializationScriptArgs:
    def __init__(__self__, *,
                 launch_profile_protocol_version: Optional[pulumi.Input[str]] = None,
                 platform: Optional[pulumi.Input[str]] = None,
                 run_context: Optional[pulumi.Input[str]] = None,
                 script: Optional[pulumi.Input[str]] = None):
        if launch_profile_protocol_version is not None:
            pulumi.set(__self__, "launch_profile_protocol_version", launch_profile_protocol_version)
        if platform is not None:
            pulumi.set(__self__, "platform", platform)
        if run_context is not None:
            pulumi.set(__self__, "run_context", run_context)
        if script is not None:
            pulumi.set(__self__, "script", script)

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

    @launch_profile_protocol_version.setter
    def launch_profile_protocol_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "launch_profile_protocol_version", value)

    @property
    @pulumi.getter
    def platform(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "platform")

    @platform.setter
    def platform(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "platform", value)

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

    @run_context.setter
    def run_context(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "run_context", value)

    @property
    @pulumi.getter
    def script(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "script")

    @script.setter
    def script(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "script", value)


@pulumi.input_type
class StudioStudioEncryptionConfigurationArgs:
    def __init__(__self__, *,
                 key_type: pulumi.Input[str],
                 key_arn: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key_type", key_type)
        if key_arn is not None:
            pulumi.set(__self__, "key_arn", key_arn)

    @property
    @pulumi.getter(name="keyType")
    def key_type(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key_type")

    @key_type.setter
    def key_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_type", value)

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

    @key_arn.setter
    def key_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_arn", value)


