pulumi-oci 2.12.0a1728593306__py3-none-any.whl → 2.13.0__py3-none-any.whl

pulumi_oci/desktops/_inputs.py

@@ -27,6 +27,16 @@ __all__ = [
     'DesktopPoolImageArgsDict',
     'DesktopPoolNetworkConfigurationArgs',
     'DesktopPoolNetworkConfigurationArgsDict',
+    'DesktopPoolPrivateAccessDetailsArgs',
+    'DesktopPoolPrivateAccessDetailsArgsDict',
+    'DesktopPoolSessionLifecycleActionsArgs',
+    'DesktopPoolSessionLifecycleActionsArgsDict',
+    'DesktopPoolSessionLifecycleActionsDisconnectArgs',
+    'DesktopPoolSessionLifecycleActionsDisconnectArgsDict',
+    'DesktopPoolSessionLifecycleActionsInactivityArgs',
+    'DesktopPoolSessionLifecycleActionsInactivityArgsDict',
+    'DesktopPoolShapeConfigArgs',
+    'DesktopPoolShapeConfigArgsDict',
     'GetDesktopPoolDesktopsFilterArgs',
     'GetDesktopPoolDesktopsFilterArgsDict',
     'GetDesktopPoolVolumesFilterArgs',
@@ -41,11 +51,11 @@ MYPY = False
 
 if not MYPY:
     class DesktopPoolAvailabilityPolicyArgsDict(TypedDict):
-        start_schedule: pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgsDict']
+        start_schedule: NotRequired[pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgsDict']]
         """
         (Updatable) Provides the schedule information for a desktop.
         """
-        stop_schedule: pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgsDict']
+        stop_schedule: NotRequired[pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgsDict']]
         """
         (Updatable) Provides the schedule information for a desktop.
         """
@@ -55,37 +65,39 @@ elif False:
 @pulumi.input_type
 class DesktopPoolAvailabilityPolicyArgs:
     def __init__(__self__, *,
-                 start_schedule: pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs'],
-                 stop_schedule: pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs']):
+                 start_schedule: Optional[pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs']] = None,
+                 stop_schedule: Optional[pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs']] = None):
         """
         :param pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs'] start_schedule: (Updatable) Provides the schedule information for a desktop.
         :param pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs'] stop_schedule: (Updatable) Provides the schedule information for a desktop.
         """
-        pulumi.set(__self__, "start_schedule", start_schedule)
-        pulumi.set(__self__, "stop_schedule", stop_schedule)
+        if start_schedule is not None:
+            pulumi.set(__self__, "start_schedule", start_schedule)
+        if stop_schedule is not None:
+            pulumi.set(__self__, "stop_schedule", stop_schedule)
 
     @property
     @pulumi.getter(name="startSchedule")
-    def start_schedule(self) -> pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs']:
+    def start_schedule(self) -> Optional[pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs']]:
         """
         (Updatable) Provides the schedule information for a desktop.
         """
         return pulumi.get(self, "start_schedule")
 
     @start_schedule.setter
-    def start_schedule(self, value: pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs']):
+    def start_schedule(self, value: Optional[pulumi.Input['DesktopPoolAvailabilityPolicyStartScheduleArgs']]):
         pulumi.set(self, "start_schedule", value)
 
     @property
     @pulumi.getter(name="stopSchedule")
-    def stop_schedule(self) -> pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs']:
+    def stop_schedule(self) -> Optional[pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs']]:
         """
         (Updatable) Provides the schedule information for a desktop.
         """
         return pulumi.get(self, "stop_schedule")
 
     @stop_schedule.setter
-    def stop_schedule(self, value: pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs']):
+    def stop_schedule(self, value: Optional[pulumi.Input['DesktopPoolAvailabilityPolicyStopScheduleArgs']]):
         pulumi.set(self, "stop_schedule", value)
 
 
@@ -344,6 +356,10 @@ if not MYPY:
         """
         The name of the desktop image.
         """
+        operating_system: NotRequired[pulumi.Input[str]]
+        """
+        The operating system of the desktop image, e.g. "Oracle Linux", "Windows".
+        """
 elif False:
     DesktopPoolImageArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -351,13 +367,17 @@ elif False:
 class DesktopPoolImageArgs:
     def __init__(__self__, *,
                  image_id: pulumi.Input[str],
-                 image_name: pulumi.Input[str]):
+                 image_name: pulumi.Input[str],
+                 operating_system: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] image_id: The OCID of the desktop image.
         :param pulumi.Input[str] image_name: The name of the desktop image.
+        :param pulumi.Input[str] operating_system: The operating system of the desktop image, e.g. "Oracle Linux", "Windows".
         """
         pulumi.set(__self__, "image_id", image_id)
         pulumi.set(__self__, "image_name", image_name)
+        if operating_system is not None:
+            pulumi.set(__self__, "operating_system", operating_system)
 
     @property
     @pulumi.getter(name="imageId")
@@ -383,16 +403,28 @@ class DesktopPoolImageArgs:
     def image_name(self, value: pulumi.Input[str]):
         pulumi.set(self, "image_name", value)
 
+    @property
+    @pulumi.getter(name="operatingSystem")
+    def operating_system(self) -> Optional[pulumi.Input[str]]:
+        """
+        The operating system of the desktop image, e.g. "Oracle Linux", "Windows".
+        """
+        return pulumi.get(self, "operating_system")
+
+    @operating_system.setter
+    def operating_system(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "operating_system", value)
+
 
 if not MYPY:
     class DesktopPoolNetworkConfigurationArgsDict(TypedDict):
         subnet_id: pulumi.Input[str]
         """
-        The OCID of the subnet to use for the desktop pool.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subnet in the customer VCN where the connectivity will be established.
         """
         vcn_id: pulumi.Input[str]
         """
-        The OCID of the VCN used by the desktop pool.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the customer VCN.
         """
 elif False:
     DesktopPoolNetworkConfigurationArgsDict: TypeAlias = Mapping[str, Any]
@@ -403,8 +435,8 @@ class DesktopPoolNetworkConfigurationArgs:
                  subnet_id: pulumi.Input[str],
                  vcn_id: pulumi.Input[str]):
         """
-        :param pulumi.Input[str] subnet_id: The OCID of the subnet to use for the desktop pool.
-        :param pulumi.Input[str] vcn_id: The OCID of the VCN used by the desktop pool.
+        :param pulumi.Input[str] subnet_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subnet in the customer VCN where the connectivity will be established.
+        :param pulumi.Input[str] vcn_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the customer VCN.
         """
         pulumi.set(__self__, "subnet_id", subnet_id)
         pulumi.set(__self__, "vcn_id", vcn_id)
@@ -413,7 +445,7 @@ class DesktopPoolNetworkConfigurationArgs:
     @pulumi.getter(name="subnetId")
     def subnet_id(self) -> pulumi.Input[str]:
         """
-        The OCID of the subnet to use for the desktop pool.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the subnet in the customer VCN where the connectivity will be established.
         """
         return pulumi.get(self, "subnet_id")
 
@@ -425,7 +457,7 @@ class DesktopPoolNetworkConfigurationArgs:
     @pulumi.getter(name="vcnId")
     def vcn_id(self) -> pulumi.Input[str]:
         """
-        The OCID of the VCN used by the desktop pool.
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the customer VCN.
         """
         return pulumi.get(self, "vcn_id")
 
@@ -434,6 +466,352 @@ class DesktopPoolNetworkConfigurationArgs:
         pulumi.set(self, "vcn_id", value)
 
 
+if not MYPY:
+    class DesktopPoolPrivateAccessDetailsArgsDict(TypedDict):
+        subnet_id: pulumi.Input[str]
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the private subnet in the customer VCN where the connectivity will be established.
+        """
+        endpoint_fqdn: NotRequired[pulumi.Input[str]]
+        """
+        The three-label FQDN to use for the private endpoint. The customer VCN's DNS records are updated with this FQDN. This enables the customer to use the FQDN instead of the private endpoint's private IP address to access the service (for example, xyz.oraclecloud.com).
+        """
+        nsg_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of network security groups for the private access.
+        """
+        private_ip: NotRequired[pulumi.Input[str]]
+        """
+        The IPv4 address from the provided Oracle Cloud Infrastructure subnet which needs to be assigned to the VNIC. If not provided, it will be auto-assigned with an available IPv4 address from the subnet.
+        """
+        vcn_id: NotRequired[pulumi.Input[str]]
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the customer VCN.
+        """
+elif False:
+    DesktopPoolPrivateAccessDetailsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DesktopPoolPrivateAccessDetailsArgs:
+    def __init__(__self__, *,
+                 subnet_id: pulumi.Input[str],
+                 endpoint_fqdn: Optional[pulumi.Input[str]] = None,
+                 nsg_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 private_ip: Optional[pulumi.Input[str]] = None,
+                 vcn_id: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] subnet_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the private subnet in the customer VCN where the connectivity will be established.
+        :param pulumi.Input[str] endpoint_fqdn: The three-label FQDN to use for the private endpoint. The customer VCN's DNS records are updated with this FQDN. This enables the customer to use the FQDN instead of the private endpoint's private IP address to access the service (for example, xyz.oraclecloud.com).
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] nsg_ids: A list of network security groups for the private access.
+        :param pulumi.Input[str] private_ip: The IPv4 address from the provided Oracle Cloud Infrastructure subnet which needs to be assigned to the VNIC. If not provided, it will be auto-assigned with an available IPv4 address from the subnet.
+        :param pulumi.Input[str] vcn_id: The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the customer VCN.
+        """
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if endpoint_fqdn is not None:
+            pulumi.set(__self__, "endpoint_fqdn", endpoint_fqdn)
+        if nsg_ids is not None:
+            pulumi.set(__self__, "nsg_ids", nsg_ids)
+        if private_ip is not None:
+            pulumi.set(__self__, "private_ip", private_ip)
+        if vcn_id is not None:
+            pulumi.set(__self__, "vcn_id", vcn_id)
+
+    @property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> pulumi.Input[str]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the private subnet in the customer VCN where the connectivity will be established.
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @subnet_id.setter
+    def subnet_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "subnet_id", value)
+
+    @property
+    @pulumi.getter(name="endpointFqdn")
+    def endpoint_fqdn(self) -> Optional[pulumi.Input[str]]:
+        """
+        The three-label FQDN to use for the private endpoint. The customer VCN's DNS records are updated with this FQDN. This enables the customer to use the FQDN instead of the private endpoint's private IP address to access the service (for example, xyz.oraclecloud.com).
+        """
+        return pulumi.get(self, "endpoint_fqdn")
+
+    @endpoint_fqdn.setter
+    def endpoint_fqdn(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "endpoint_fqdn", value)
+
+    @property
+    @pulumi.getter(name="nsgIds")
+    def nsg_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A list of network security groups for the private access.
+        """
+        return pulumi.get(self, "nsg_ids")
+
+    @nsg_ids.setter
+    def nsg_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "nsg_ids", value)
+
+    @property
+    @pulumi.getter(name="privateIp")
+    def private_ip(self) -> Optional[pulumi.Input[str]]:
+        """
+        The IPv4 address from the provided Oracle Cloud Infrastructure subnet which needs to be assigned to the VNIC. If not provided, it will be auto-assigned with an available IPv4 address from the subnet.
+        """
+        return pulumi.get(self, "private_ip")
+
+    @private_ip.setter
+    def private_ip(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "private_ip", value)
+
+    @property
+    @pulumi.getter(name="vcnId")
+    def vcn_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        The [OCID](https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm) of the customer VCN.
+        """
+        return pulumi.get(self, "vcn_id")
+
+    @vcn_id.setter
+    def vcn_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "vcn_id", value)
+
+
+if not MYPY:
+    class DesktopPoolSessionLifecycleActionsArgsDict(TypedDict):
+        disconnect: NotRequired[pulumi.Input['DesktopPoolSessionLifecycleActionsDisconnectArgsDict']]
+        """
+        (Updatable) Action and grace period for disconnect
+        """
+        inactivity: NotRequired[pulumi.Input['DesktopPoolSessionLifecycleActionsInactivityArgsDict']]
+        """
+        (Updatable) Action and grace period for inactivity
+        """
+elif False:
+    DesktopPoolSessionLifecycleActionsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DesktopPoolSessionLifecycleActionsArgs:
+    def __init__(__self__, *,
+                 disconnect: Optional[pulumi.Input['DesktopPoolSessionLifecycleActionsDisconnectArgs']] = None,
+                 inactivity: Optional[pulumi.Input['DesktopPoolSessionLifecycleActionsInactivityArgs']] = None):
+        """
+        :param pulumi.Input['DesktopPoolSessionLifecycleActionsDisconnectArgs'] disconnect: (Updatable) Action and grace period for disconnect
+        :param pulumi.Input['DesktopPoolSessionLifecycleActionsInactivityArgs'] inactivity: (Updatable) Action and grace period for inactivity
+        """
+        if disconnect is not None:
+            pulumi.set(__self__, "disconnect", disconnect)
+        if inactivity is not None:
+            pulumi.set(__self__, "inactivity", inactivity)
+
+    @property
+    @pulumi.getter
+    def disconnect(self) -> Optional[pulumi.Input['DesktopPoolSessionLifecycleActionsDisconnectArgs']]:
+        """
+        (Updatable) Action and grace period for disconnect
+        """
+        return pulumi.get(self, "disconnect")
+
+    @disconnect.setter
+    def disconnect(self, value: Optional[pulumi.Input['DesktopPoolSessionLifecycleActionsDisconnectArgs']]):
+        pulumi.set(self, "disconnect", value)
+
+    @property
+    @pulumi.getter
+    def inactivity(self) -> Optional[pulumi.Input['DesktopPoolSessionLifecycleActionsInactivityArgs']]:
+        """
+        (Updatable) Action and grace period for inactivity
+        """
+        return pulumi.get(self, "inactivity")
+
+    @inactivity.setter
+    def inactivity(self, value: Optional[pulumi.Input['DesktopPoolSessionLifecycleActionsInactivityArgs']]):
+        pulumi.set(self, "inactivity", value)
+
+
+if not MYPY:
+    class DesktopPoolSessionLifecycleActionsDisconnectArgsDict(TypedDict):
+        action: pulumi.Input[str]
+        """
+        (Updatable) a disconnect action to be triggered
+        """
+        grace_period_in_minutes: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) The period of time (in minutes) after disconnect before any action occurs. If the value is not provided, a default value is used.
+        """
+elif False:
+    DesktopPoolSessionLifecycleActionsDisconnectArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DesktopPoolSessionLifecycleActionsDisconnectArgs:
+    def __init__(__self__, *,
+                 action: pulumi.Input[str],
+                 grace_period_in_minutes: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] action: (Updatable) a disconnect action to be triggered
+        :param pulumi.Input[int] grace_period_in_minutes: (Updatable) The period of time (in minutes) after disconnect before any action occurs. If the value is not provided, a default value is used.
+        """
+        pulumi.set(__self__, "action", action)
+        if grace_period_in_minutes is not None:
+            pulumi.set(__self__, "grace_period_in_minutes", grace_period_in_minutes)
+
+    @property
+    @pulumi.getter
+    def action(self) -> pulumi.Input[str]:
+        """
+        (Updatable) a disconnect action to be triggered
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: pulumi.Input[str]):
+        pulumi.set(self, "action", value)
+
+    @property
+    @pulumi.getter(name="gracePeriodInMinutes")
+    def grace_period_in_minutes(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The period of time (in minutes) after disconnect before any action occurs. If the value is not provided, a default value is used.
+        """
+        return pulumi.get(self, "grace_period_in_minutes")
+
+    @grace_period_in_minutes.setter
+    def grace_period_in_minutes(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "grace_period_in_minutes", value)
+
+
+if not MYPY:
+    class DesktopPoolSessionLifecycleActionsInactivityArgsDict(TypedDict):
+        action: pulumi.Input[str]
+        """
+        (Updatable) an inactivity action to be triggered
+        """
+        grace_period_in_minutes: NotRequired[pulumi.Input[int]]
+        """
+        (Updatable) The period of time (in minutes) during which the session must remain inactive before any action occurs. If the value is not provided, a default value is used.
+        """
+elif False:
+    DesktopPoolSessionLifecycleActionsInactivityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DesktopPoolSessionLifecycleActionsInactivityArgs:
+    def __init__(__self__, *,
+                 action: pulumi.Input[str],
+                 grace_period_in_minutes: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] action: (Updatable) an inactivity action to be triggered
+        :param pulumi.Input[int] grace_period_in_minutes: (Updatable) The period of time (in minutes) during which the session must remain inactive before any action occurs. If the value is not provided, a default value is used.
+        """
+        pulumi.set(__self__, "action", action)
+        if grace_period_in_minutes is not None:
+            pulumi.set(__self__, "grace_period_in_minutes", grace_period_in_minutes)
+
+    @property
+    @pulumi.getter
+    def action(self) -> pulumi.Input[str]:
+        """
+        (Updatable) an inactivity action to be triggered
+        """
+        return pulumi.get(self, "action")
+
+    @action.setter
+    def action(self, value: pulumi.Input[str]):
+        pulumi.set(self, "action", value)
+
+    @property
+    @pulumi.getter(name="gracePeriodInMinutes")
+    def grace_period_in_minutes(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Updatable) The period of time (in minutes) during which the session must remain inactive before any action occurs. If the value is not provided, a default value is used.
+        """
+        return pulumi.get(self, "grace_period_in_minutes")
+
+    @grace_period_in_minutes.setter
+    def grace_period_in_minutes(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "grace_period_in_minutes", value)
+
+
+if not MYPY:
+    class DesktopPoolShapeConfigArgsDict(TypedDict):
+        baseline_ocpu_utilization: NotRequired[pulumi.Input[str]]
+        """
+        The baseline OCPU utilization for a subcore burstable VM instance used for each desktop compute instance in the desktop pool. Leave this attribute blank for a non-burstable instance, or explicitly specify non-burstable with `BASELINE_1_1`. The following values are supported:
+        * `BASELINE_1_8` - baseline usage is 1/8 of an OCPU.
+        * `BASELINE_1_2` - baseline usage is 1/2 of an OCPU.
+        * `BASELINE_1_1` - baseline usage is the entire OCPU. This represents a non-burstable instance.
+        """
+        memory_in_gbs: NotRequired[pulumi.Input[str]]
+        """
+        The total amount of memory available in gigabytes for each desktop compute instance in the desktop pool.
+        """
+        ocpus: NotRequired[pulumi.Input[str]]
+        """
+        The total number of OCPUs available for each desktop compute instance in the desktop pool.
+        """
+elif False:
+    DesktopPoolShapeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DesktopPoolShapeConfigArgs:
+    def __init__(__self__, *,
+                 baseline_ocpu_utilization: Optional[pulumi.Input[str]] = None,
+                 memory_in_gbs: Optional[pulumi.Input[str]] = None,
+                 ocpus: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] baseline_ocpu_utilization: The baseline OCPU utilization for a subcore burstable VM instance used for each desktop compute instance in the desktop pool. Leave this attribute blank for a non-burstable instance, or explicitly specify non-burstable with `BASELINE_1_1`. The following values are supported:
+               * `BASELINE_1_8` - baseline usage is 1/8 of an OCPU.
+               * `BASELINE_1_2` - baseline usage is 1/2 of an OCPU.
+               * `BASELINE_1_1` - baseline usage is the entire OCPU. This represents a non-burstable instance.
+        :param pulumi.Input[str] memory_in_gbs: The total amount of memory available in gigabytes for each desktop compute instance in the desktop pool.
+        :param pulumi.Input[str] ocpus: The total number of OCPUs available for each desktop compute instance in the desktop pool.
+        """
+        if baseline_ocpu_utilization is not None:
+            pulumi.set(__self__, "baseline_ocpu_utilization", baseline_ocpu_utilization)
+        if memory_in_gbs is not None:
+            pulumi.set(__self__, "memory_in_gbs", memory_in_gbs)
+        if ocpus is not None:
+            pulumi.set(__self__, "ocpus", ocpus)
+
+    @property
+    @pulumi.getter(name="baselineOcpuUtilization")
+    def baseline_ocpu_utilization(self) -> Optional[pulumi.Input[str]]:
+        """
+        The baseline OCPU utilization for a subcore burstable VM instance used for each desktop compute instance in the desktop pool. Leave this attribute blank for a non-burstable instance, or explicitly specify non-burstable with `BASELINE_1_1`. The following values are supported:
+        * `BASELINE_1_8` - baseline usage is 1/8 of an OCPU.
+        * `BASELINE_1_2` - baseline usage is 1/2 of an OCPU.
+        * `BASELINE_1_1` - baseline usage is the entire OCPU. This represents a non-burstable instance.
+        """
+        return pulumi.get(self, "baseline_ocpu_utilization")
+
+    @baseline_ocpu_utilization.setter
+    def baseline_ocpu_utilization(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "baseline_ocpu_utilization", value)
+
+    @property
+    @pulumi.getter(name="memoryInGbs")
+    def memory_in_gbs(self) -> Optional[pulumi.Input[str]]:
+        """
+        The total amount of memory available in gigabytes for each desktop compute instance in the desktop pool.
+        """
+        return pulumi.get(self, "memory_in_gbs")
+
+    @memory_in_gbs.setter
+    def memory_in_gbs(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "memory_in_gbs", value)
+
+    @property
+    @pulumi.getter
+    def ocpus(self) -> Optional[pulumi.Input[str]]:
+        """
+        The total number of OCPUs available for each desktop compute instance in the desktop pool.
+        """
+        return pulumi.get(self, "ocpus")
+
+    @ocpus.setter
+    def ocpus(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ocpus", value)
+
+
 if not MYPY:
     class GetDesktopPoolDesktopsFilterArgsDict(TypedDict):
         name: str