PyPI - pulumi-harness - Versions diffs - 0.9.0a1760076204__py3-none-any.whl → 0.10.0a1764049859__py3-none-any.whl - Mend

pulumi-harness 0.9.0a1760076204py3-none-any.whl → 0.10.0a1764049859py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

pulumi_harness/__init__.py +24 -0
pulumi_harness/autostopping/__init__.py +2 -0
pulumi_harness/autostopping/_inputs.py +1698 -622
pulumi_harness/autostopping/get_aws_alb.py +4 -0
pulumi_harness/autostopping/get_aws_proxy.py +4 -0
pulumi_harness/autostopping/get_azure_gateway.py +4 -0
pulumi_harness/autostopping/get_azure_proxy.py +4 -0
pulumi_harness/autostopping/get_gcp_proxy.py +4 -0
pulumi_harness/autostopping/get_rule_ecs.py +4 -0
pulumi_harness/autostopping/get_rule_rds.py +4 -0
pulumi_harness/autostopping/get_rule_scale_group.py +254 -0
pulumi_harness/autostopping/get_rule_vm.py +4 -0
pulumi_harness/autostopping/outputs.py +727 -0
pulumi_harness/autostopping/rule_ecs.py +58 -0
pulumi_harness/autostopping/rule_scale_group.py +592 -0
pulumi_harness/cluster/get_orchestrator.py +4 -0
pulumi_harness/cluster/get_orchestrator_config.py +21 -1
pulumi_harness/cluster/orchestrator.py +2 -28
pulumi_harness/cluster/orchestrator_config.py +49 -0
pulumi_harness/platform/__init__.py +5 -0
pulumi_harness/platform/_inputs.py +5804 -371
pulumi_harness/platform/connector_rancher.py +36 -0
pulumi_harness/platform/db_instance.py +49 -49
pulumi_harness/platform/db_schema.py +243 -0
pulumi_harness/platform/environment.py +166 -0
pulumi_harness/platform/environment_group.py +10 -10
pulumi_harness/platform/gcp_secret_manager_connector.py +94 -0
pulumi_harness/platform/get_db_instance.py +21 -21
pulumi_harness/platform/get_db_schema.py +21 -1
pulumi_harness/platform/get_default_notification_template_set.py +31 -1
pulumi_harness/platform/get_gitops_agent_operator_yaml.py +4 -0
pulumi_harness/platform/get_gitops_app_project_mapping.py +4 -0
pulumi_harness/platform/get_gitops_applications.py +4 -0
pulumi_harness/platform/get_gitops_repo_cert.py +4 -0
pulumi_harness/platform/get_infra_module.py +192 -6
pulumi_harness/platform/get_infra_module_testing.py +521 -0
pulumi_harness/platform/get_infra_modules.py +103 -0
pulumi_harness/platform/get_manual_freeze.py +4 -0
pulumi_harness/platform/get_pipeline_central_notification_rule.py +2 -26
pulumi_harness/platform/get_secret_winrm.py +263 -0
pulumi_harness/platform/git_ops_applications.py +0 -4
pulumi_harness/platform/gitops_applicationset.py +308 -6
pulumi_harness/platform/infra_module_testing.py +1134 -0
pulumi_harness/platform/infrastructure.py +82 -0
pulumi_harness/platform/outputs.py +4467 -251
pulumi_harness/platform/pipeline.py +2 -2
pulumi_harness/platform/pipeline_central_notification_rule.py +187 -0
pulumi_harness/platform/secret_winrm.py +1082 -0
pulumi_harness/platform/service.py +150 -0
pulumi_harness/platform/triggers.py +6 -4
pulumi_harness/pulumi-plugin.json +1 -1
{pulumi_harness-0.9.0a1760076204.dist-info → pulumi_harness-0.10.0a1764049859.dist-info}/METADATA +1 -1
{pulumi_harness-0.9.0a1760076204.dist-info → pulumi_harness-0.10.0a1764049859.dist-info}/RECORD +55 -48
{pulumi_harness-0.9.0a1760076204.dist-info → pulumi_harness-0.10.0a1764049859.dist-info}/WHEEL +0 -0
{pulumi_harness-0.9.0a1760076204.dist-info → pulumi_harness-0.10.0a1764049859.dist-info}/top_level.txt +0 -0

pulumi_harness/autostopping/_inputs.py CHANGED Viewed

@@ -35,6 +35,16 @@ __all__ = [
     'RuleRdsTcpArgsDict',
     'RuleRdsTcpForwardRuleArgs',
     'RuleRdsTcpForwardRuleArgsDict',
+    'RuleScaleGroupDependArgs',
+    'RuleScaleGroupDependArgsDict',
+    'RuleScaleGroupHttpArgs',
+    'RuleScaleGroupHttpArgsDict',
+    'RuleScaleGroupHttpHealthArgs',
+    'RuleScaleGroupHttpHealthArgsDict',
+    'RuleScaleGroupHttpRoutingArgs',
+    'RuleScaleGroupHttpRoutingArgsDict',
+    'RuleScaleGroupScaleGroupArgs',
+    'RuleScaleGroupScaleGroupArgsDict',
     'RuleVmDependArgs',
     'RuleVmDependArgsDict',
     'RuleVmFilterArgs',
@@ -77,6 +87,16 @@ __all__ = [
     'GetRuleRdsTcpArgsDict',
     'GetRuleRdsTcpForwardRuleArgs',
     'GetRuleRdsTcpForwardRuleArgsDict',
+    'GetRuleScaleGroupDependArgs',
+    'GetRuleScaleGroupDependArgsDict',
+    'GetRuleScaleGroupHttpArgs',
+    'GetRuleScaleGroupHttpArgsDict',
+    'GetRuleScaleGroupHttpHealthArgs',
+    'GetRuleScaleGroupHttpHealthArgsDict',
+    'GetRuleScaleGroupHttpRoutingArgs',
+    'GetRuleScaleGroupHttpRoutingArgsDict',
+    'GetRuleScaleGroupScaleGroupArgs',
+    'GetRuleScaleGroupScaleGroupArgsDict',
     'GetRuleVmDependArgs',
     'GetRuleVmDependArgsDict',
     'GetRuleVmFilterArgs',
@@ -626,7 +646,7 @@ class RuleRdsTcpForwardRuleArgs:
 if not MYPY:
-    class RuleVmDependArgsDict(TypedDict):
+    class RuleScaleGroupDependArgsDict(TypedDict):
         rule_id: pulumi.Input[_builtins.int]
         """
         Rule id of the dependent rule
@@ -636,10 +656,10 @@ if not MYPY:
         Number of seconds the rule should wait after warming up the dependent rule
         """
 elif False:
-    RuleVmDependArgsDict: TypeAlias = Mapping[str, Any]
+    RuleScaleGroupDependArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmDependArgs:
+class RuleScaleGroupDependArgs:
     def __init__(__self__, *,
                  rule_id: pulumi.Input[_builtins.int],
                  delay_in_sec: Optional[pulumi.Input[_builtins.int]] = None):
@@ -677,157 +697,32 @@ class RuleVmDependArgs:
 if not MYPY:
-    class RuleVmFilterArgsDict(TypedDict):
-        vm_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
-        """
-        Ids of instances that needs to be managed using the AutoStopping rules
-        """
-        regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        Regions of instances that needs to be managed using the AutoStopping rules
-        """
-        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgsDict']]]]
-        """
-        Tags of instances that needs to be managed using the AutoStopping rules
-        """
-        zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        Zones of instances that needs to be managed using the AutoStopping rules
-        """
-elif False:
-    RuleVmFilterArgsDict: TypeAlias = Mapping[str, Any]
-@pulumi.input_type
-class RuleVmFilterArgs:
-    def __init__(__self__, *,
-                 vm_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
-                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
-                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]] = None,
-                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] vm_ids: Ids of instances that needs to be managed using the AutoStopping rules
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regions: Regions of instances that needs to be managed using the AutoStopping rules
-        :param pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]] tags: Tags of instances that needs to be managed using the AutoStopping rules
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] zones: Zones of instances that needs to be managed using the AutoStopping rules
-        """
-        pulumi.set(__self__, "vm_ids", vm_ids)
-        if regions is not None:
-            pulumi.set(__self__, "regions", regions)
-        if tags is not None:
-            pulumi.set(__self__, "tags", tags)
-        if zones is not None:
-            pulumi.set(__self__, "zones", zones)
-    @_builtins.property
-    @pulumi.getter(name="vmIds")
-    def vm_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
-        """
-        Ids of instances that needs to be managed using the AutoStopping rules
-        """
-        return pulumi.get(self, "vm_ids")
-    @vm_ids.setter
-    def vm_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
-        pulumi.set(self, "vm_ids", value)
-    @_builtins.property
-    @pulumi.getter
-    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        Regions of instances that needs to be managed using the AutoStopping rules
-        """
-        return pulumi.get(self, "regions")
-    @regions.setter
-    def regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "regions", value)
-    @_builtins.property
-    @pulumi.getter
-    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]]:
-        """
-        Tags of instances that needs to be managed using the AutoStopping rules
-        """
-        return pulumi.get(self, "tags")
-    @tags.setter
-    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]]):
-        pulumi.set(self, "tags", value)
-    @_builtins.property
-    @pulumi.getter
-    def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        Zones of instances that needs to be managed using the AutoStopping rules
-        """
-        return pulumi.get(self, "zones")
-    @zones.setter
-    def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "zones", value)
-if not MYPY:
-    class RuleVmFilterTagArgsDict(TypedDict):
-        key: pulumi.Input[_builtins.str]
-        value: pulumi.Input[_builtins.str]
-elif False:
-    RuleVmFilterTagArgsDict: TypeAlias = Mapping[str, Any]
-@pulumi.input_type
-class RuleVmFilterTagArgs:
-    def __init__(__self__, *,
-                 key: pulumi.Input[_builtins.str],
-                 value: pulumi.Input[_builtins.str]):
-        pulumi.set(__self__, "key", key)
-        pulumi.set(__self__, "value", value)
-    @_builtins.property
-    @pulumi.getter
-    def key(self) -> pulumi.Input[_builtins.str]:
-        return pulumi.get(self, "key")
-    @key.setter
-    def key(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "key", value)
-    @_builtins.property
-    @pulumi.getter
-    def value(self) -> pulumi.Input[_builtins.str]:
-        return pulumi.get(self, "value")
-    @value.setter
-    def value(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "value", value)
-if not MYPY:
-    class RuleVmHttpArgsDict(TypedDict):
+    class RuleScaleGroupHttpArgsDict(TypedDict):
         proxy_id: pulumi.Input[_builtins.str]
         """
         Id of the proxy
         """
-        healths: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgsDict']]]]
+        healths: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpHealthArgsDict']]]]
         """
         Health Check Details
         """
-        routings: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgsDict']]]]
+        routings: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpRoutingArgsDict']]]]
         """
-        Routing configuration used to access the instances
+        Routing configuration used to access the scaling group
         """
 elif False:
-    RuleVmHttpArgsDict: TypeAlias = Mapping[str, Any]
+    RuleScaleGroupHttpArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmHttpArgs:
+class RuleScaleGroupHttpArgs:
     def __init__(__self__, *,
                  proxy_id: pulumi.Input[_builtins.str],
-                 healths: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]] = None,
-                 routings: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]] = None):
+                 healths: Optional[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpHealthArgs']]]] = None,
+                 routings: Optional[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpRoutingArgs']]]] = None):
         """
         :param pulumi.Input[_builtins.str] proxy_id: Id of the proxy
-        :param pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]] healths: Health Check Details
-        :param pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]] routings: Routing configuration used to access the instances
+        :param pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpHealthArgs']]] healths: Health Check Details
+        :param pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpRoutingArgs']]] routings: Routing configuration used to access the scaling group
         """
         pulumi.set(__self__, "proxy_id", proxy_id)
         if healths is not None:
@@ -849,31 +744,31 @@ class RuleVmHttpArgs:
     @_builtins.property
     @pulumi.getter
-    def healths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]]:
+    def healths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpHealthArgs']]]]:
         """
         Health Check Details
         """
         return pulumi.get(self, "healths")
     @healths.setter
-    def healths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]]):
+    def healths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpHealthArgs']]]]):
         pulumi.set(self, "healths", value)
     @_builtins.property
     @pulumi.getter
-    def routings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]]:
+    def routings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpRoutingArgs']]]]:
         """
-        Routing configuration used to access the instances
+        Routing configuration used to access the scaling group
         """
         return pulumi.get(self, "routings")
     @routings.setter
-    def routings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]]):
+    def routings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleScaleGroupHttpRoutingArgs']]]]):
         pulumi.set(self, "routings", value)
 if not MYPY:
-    class RuleVmHttpHealthArgsDict(TypedDict):
+    class RuleScaleGroupHttpHealthArgsDict(TypedDict):
         port: pulumi.Input[_builtins.int]
         """
         Health check port on the VM
@@ -899,10 +794,10 @@ if not MYPY:
         Health check timeout
         """
 elif False:
-    RuleVmHttpHealthArgsDict: TypeAlias = Mapping[str, Any]
+    RuleScaleGroupHttpHealthArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmHttpHealthArgs:
+class RuleScaleGroupHttpHealthArgs:
     def __init__(__self__, *,
                  port: pulumi.Input[_builtins.int],
                  protocol: pulumi.Input[_builtins.str],
@@ -1003,7 +898,7 @@ class RuleVmHttpHealthArgs:
 if not MYPY:
-    class RuleVmHttpRoutingArgsDict(TypedDict):
+    class RuleScaleGroupHttpRoutingArgsDict(TypedDict):
         source_protocol: pulumi.Input[_builtins.str]
         """
         Source protocol of the proxy can be http or https
@@ -1025,10 +920,10 @@ if not MYPY:
         Port on the VM
         """
 elif False:
-    RuleVmHttpRoutingArgsDict: TypeAlias = Mapping[str, Any]
+    RuleScaleGroupHttpRoutingArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmHttpRoutingArgs:
+class RuleScaleGroupHttpRoutingArgs:
     def __init__(__self__, *,
                  source_protocol: pulumi.Input[_builtins.str],
                  target_protocol: pulumi.Input[_builtins.str],
@@ -1113,563 +1008,1501 @@ class RuleVmHttpRoutingArgs:
 if not MYPY:
-    class RuleVmTcpArgsDict(TypedDict):
-        proxy_id: pulumi.Input[_builtins.str]
+    class RuleScaleGroupScaleGroupArgsDict(TypedDict):
+        desired: pulumi.Input[_builtins.int]
         """
-        Id of the Proxy
+        Desired capacity of the Scaling Group
         """
-        forward_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgsDict']]]]
+        id: pulumi.Input[_builtins.str]
         """
-        Additional tcp forwarding rules
+        ID of the Scaling Group
         """
-        rdps: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgsDict']]]]
+        max: pulumi.Input[_builtins.int]
         """
-        RDP configuration
+        Maximum capacity of the Scaling Group
         """
-        sshes: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgsDict']]]]
+        min: pulumi.Input[_builtins.int]
         """
-        SSH configuration
+        Minimum capacity of the Scaling Group
+        """
+        name: pulumi.Input[_builtins.str]
+        """
+        Name of the Scaling Group
+        """
+        on_demand: pulumi.Input[_builtins.int]
+        """
+        On-demand capacity of the Scaling Group
+        """
+        region: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Region of the Scaling Group
+        """
+        zone: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Zone of the Scaling Group. Needed for GCP only
         """
 elif False:
-    RuleVmTcpArgsDict: TypeAlias = Mapping[str, Any]
+    RuleScaleGroupScaleGroupArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmTcpArgs:
+class RuleScaleGroupScaleGroupArgs:
     def __init__(__self__, *,
-                 proxy_id: pulumi.Input[_builtins.str],
-                 forward_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]] = None,
-                 rdps: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]] = None,
-                 sshes: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]] = None):
-        """
-        :param pulumi.Input[_builtins.str] proxy_id: Id of the Proxy
-        :param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]] forward_rules: Additional tcp forwarding rules
-        :param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]] rdps: RDP configuration
-        :param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]] sshes: SSH configuration
-        """
-        pulumi.set(__self__, "proxy_id", proxy_id)
-        if forward_rules is not None:
-            pulumi.set(__self__, "forward_rules", forward_rules)
-        if rdps is not None:
-            pulumi.set(__self__, "rdps", rdps)
-        if sshes is not None:
-            pulumi.set(__self__, "sshes", sshes)
+                 desired: pulumi.Input[_builtins.int],
+                 id: pulumi.Input[_builtins.str],
+                 max: pulumi.Input[_builtins.int],
+                 min: pulumi.Input[_builtins.int],
+                 name: pulumi.Input[_builtins.str],
+                 on_demand: pulumi.Input[_builtins.int],
+                 region: Optional[pulumi.Input[_builtins.str]] = None,
+                 zone: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.int] desired: Desired capacity of the Scaling Group
+        :param pulumi.Input[_builtins.str] id: ID of the Scaling Group
+        :param pulumi.Input[_builtins.int] max: Maximum capacity of the Scaling Group
+        :param pulumi.Input[_builtins.int] min: Minimum capacity of the Scaling Group
+        :param pulumi.Input[_builtins.str] name: Name of the Scaling Group
+        :param pulumi.Input[_builtins.int] on_demand: On-demand capacity of the Scaling Group
+        :param pulumi.Input[_builtins.str] region: Region of the Scaling Group
+        :param pulumi.Input[_builtins.str] zone: Zone of the Scaling Group. Needed for GCP only
+        """
+        pulumi.set(__self__, "desired", desired)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "max", max)
+        pulumi.set(__self__, "min", min)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "on_demand", on_demand)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
     @_builtins.property
-    @pulumi.getter(name="proxyId")
-    def proxy_id(self) -> pulumi.Input[_builtins.str]:
+    @pulumi.getter
+    def desired(self) -> pulumi.Input[_builtins.int]:
         """
-        Id of the Proxy
+        Desired capacity of the Scaling Group
         """
-        return pulumi.get(self, "proxy_id")
+        return pulumi.get(self, "desired")
-    @proxy_id.setter
-    def proxy_id(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "proxy_id", value)
+    @desired.setter
+    def desired(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "desired", value)
     @_builtins.property
-    @pulumi.getter(name="forwardRules")
-    def forward_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]]:
+    @pulumi.getter
+    def id(self) -> pulumi.Input[_builtins.str]:
         """
-        Additional tcp forwarding rules
+        ID of the Scaling Group
         """
-        return pulumi.get(self, "forward_rules")
+        return pulumi.get(self, "id")
-    @forward_rules.setter
-    def forward_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]]):
-        pulumi.set(self, "forward_rules", value)
+    @id.setter
+    def id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "id", value)
     @_builtins.property
     @pulumi.getter
-    def rdps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]]:
+    def max(self) -> pulumi.Input[_builtins.int]:
         """
-        RDP configuration
+        Maximum capacity of the Scaling Group
         """
-        return pulumi.get(self, "rdps")
+        return pulumi.get(self, "max")
-    @rdps.setter
-    def rdps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]]):
-        pulumi.set(self, "rdps", value)
+    @max.setter
+    def max(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "max", value)
     @_builtins.property
     @pulumi.getter
-    def sshes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]]:
+    def min(self) -> pulumi.Input[_builtins.int]:
         """
-        SSH configuration
+        Minimum capacity of the Scaling Group
         """
-        return pulumi.get(self, "sshes")
-    @sshes.setter
-    def sshes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]]):
-        pulumi.set(self, "sshes", value)
+        return pulumi.get(self, "min")
+    @min.setter
+    def min(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "min", value)
-if not MYPY:
-    class RuleVmTcpForwardRuleArgsDict(TypedDict):
-        port: pulumi.Input[_builtins.int]
-        """
-        Port to listen on the vm
-        """
-        connect_on: NotRequired[pulumi.Input[_builtins.int]]
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[_builtins.str]:
         """
-        Port to listen on the proxy
+        Name of the Scaling Group
         """
-elif False:
-    RuleVmTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "name")
-@pulumi.input_type
-class RuleVmTcpForwardRuleArgs:
-    def __init__(__self__, *,
-                 port: pulumi.Input[_builtins.int],
-                 connect_on: Optional[pulumi.Input[_builtins.int]] = None):
+    @name.setter
+    def name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "name", value)
+    @_builtins.property
+    @pulumi.getter(name="onDemand")
+    def on_demand(self) -> pulumi.Input[_builtins.int]:
         """
-        :param pulumi.Input[_builtins.int] port: Port to listen on the vm
-        :param pulumi.Input[_builtins.int] connect_on: Port to listen on the proxy
+        On-demand capacity of the Scaling Group
         """
-        pulumi.set(__self__, "port", port)
-        if connect_on is not None:
-            pulumi.set(__self__, "connect_on", connect_on)
+        return pulumi.get(self, "on_demand")
+    @on_demand.setter
+    def on_demand(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "on_demand", value)
     @_builtins.property
     @pulumi.getter
-    def port(self) -> pulumi.Input[_builtins.int]:
+    def region(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Port to listen on the vm
+        Region of the Scaling Group
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "region")
-    @port.setter
-    def port(self, value: pulumi.Input[_builtins.int]):
-        pulumi.set(self, "port", value)
+    @region.setter
+    def region(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "region", value)
     @_builtins.property
-    @pulumi.getter(name="connectOn")
-    def connect_on(self) -> Optional[pulumi.Input[_builtins.int]]:
+    @pulumi.getter
+    def zone(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        Port to listen on the proxy
+        Zone of the Scaling Group. Needed for GCP only
         """
-        return pulumi.get(self, "connect_on")
+        return pulumi.get(self, "zone")
-    @connect_on.setter
-    def connect_on(self, value: Optional[pulumi.Input[_builtins.int]]):
-        pulumi.set(self, "connect_on", value)
+    @zone.setter
+    def zone(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "zone", value)
 if not MYPY:
-    class RuleVmTcpRdpArgsDict(TypedDict):
-        connect_on: NotRequired[pulumi.Input[_builtins.int]]
+    class RuleVmDependArgsDict(TypedDict):
+        rule_id: pulumi.Input[_builtins.int]
         """
-        Port to listen on the proxy
+        Rule id of the dependent rule
         """
-        port: NotRequired[pulumi.Input[_builtins.int]]
+        delay_in_sec: NotRequired[pulumi.Input[_builtins.int]]
         """
-        Port to listen on the vm
+        Number of seconds the rule should wait after warming up the dependent rule
         """
 elif False:
-    RuleVmTcpRdpArgsDict: TypeAlias = Mapping[str, Any]
+    RuleVmDependArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmTcpRdpArgs:
+class RuleVmDependArgs:
     def __init__(__self__, *,
-                 connect_on: Optional[pulumi.Input[_builtins.int]] = None,
-                 port: Optional[pulumi.Input[_builtins.int]] = None):
+                 rule_id: pulumi.Input[_builtins.int],
+                 delay_in_sec: Optional[pulumi.Input[_builtins.int]] = None):
         """
-        :param pulumi.Input[_builtins.int] connect_on: Port to listen on the proxy
-        :param pulumi.Input[_builtins.int] port: Port to listen on the vm
+        :param pulumi.Input[_builtins.int] rule_id: Rule id of the dependent rule
+        :param pulumi.Input[_builtins.int] delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
         """
-        if connect_on is not None:
-            pulumi.set(__self__, "connect_on", connect_on)
-        if port is not None:
-            pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "rule_id", rule_id)
+        if delay_in_sec is not None:
+            pulumi.set(__self__, "delay_in_sec", delay_in_sec)
     @_builtins.property
-    @pulumi.getter(name="connectOn")
-    def connect_on(self) -> Optional[pulumi.Input[_builtins.int]]:
+    @pulumi.getter(name="ruleId")
+    def rule_id(self) -> pulumi.Input[_builtins.int]:
         """
-        Port to listen on the proxy
+        Rule id of the dependent rule
         """
-        return pulumi.get(self, "connect_on")
+        return pulumi.get(self, "rule_id")
+    @rule_id.setter
+    def rule_id(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "rule_id", value)
+    @_builtins.property
+    @pulumi.getter(name="delayInSec")
+    def delay_in_sec(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Number of seconds the rule should wait after warming up the dependent rule
+        """
+        return pulumi.get(self, "delay_in_sec")
+    @delay_in_sec.setter
+    def delay_in_sec(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "delay_in_sec", value)
-    @connect_on.setter
-    def connect_on(self, value: Optional[pulumi.Input[_builtins.int]]):
-        pulumi.set(self, "connect_on", value)
+if not MYPY:
+    class RuleVmFilterArgsDict(TypedDict):
+        vm_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
+        """
+        Ids of instances that needs to be managed using the AutoStopping rules
+        """
+        regions: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        Regions of instances that needs to be managed using the AutoStopping rules
+        """
+        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgsDict']]]]
+        """
+        Tags of instances that needs to be managed using the AutoStopping rules
+        """
+        zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        Zones of instances that needs to be managed using the AutoStopping rules
+        """
+elif False:
+    RuleVmFilterArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmFilterArgs:
+    def __init__(__self__, *,
+                 vm_ids: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
+                 regions: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
+                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]] = None,
+                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] vm_ids: Ids of instances that needs to be managed using the AutoStopping rules
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regions: Regions of instances that needs to be managed using the AutoStopping rules
+        :param pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]] tags: Tags of instances that needs to be managed using the AutoStopping rules
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] zones: Zones of instances that needs to be managed using the AutoStopping rules
+        """
+        pulumi.set(__self__, "vm_ids", vm_ids)
+        if regions is not None:
+            pulumi.set(__self__, "regions", regions)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+        if zones is not None:
+            pulumi.set(__self__, "zones", zones)
+    @_builtins.property
+    @pulumi.getter(name="vmIds")
+    def vm_ids(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
+        """
+        Ids of instances that needs to be managed using the AutoStopping rules
+        """
+        return pulumi.get(self, "vm_ids")
+    @vm_ids.setter
+    def vm_ids(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(self, "vm_ids", value)
     @_builtins.property
     @pulumi.getter
-    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
+    def regions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        Port to listen on the vm
+        Regions of instances that needs to be managed using the AutoStopping rules
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "regions")
-    @port.setter
-    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
-        pulumi.set(self, "port", value)
+    @regions.setter
+    def regions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "regions", value)
+    @_builtins.property
+    @pulumi.getter
+    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]]:
+        """
+        Tags of instances that needs to be managed using the AutoStopping rules
+        """
+        return pulumi.get(self, "tags")
+    @tags.setter
+    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmFilterTagArgs']]]]):
+        pulumi.set(self, "tags", value)
+    @_builtins.property
+    @pulumi.getter
+    def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        Zones of instances that needs to be managed using the AutoStopping rules
+        """
+        return pulumi.get(self, "zones")
+    @zones.setter
+    def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "zones", value)
 if not MYPY:
-    class RuleVmTcpSshArgsDict(TypedDict):
-        connect_on: NotRequired[pulumi.Input[_builtins.int]]
+    class RuleVmFilterTagArgsDict(TypedDict):
+        key: pulumi.Input[_builtins.str]
+        value: pulumi.Input[_builtins.str]
+elif False:
+    RuleVmFilterTagArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmFilterTagArgs:
+    def __init__(__self__, *,
+                 key: pulumi.Input[_builtins.str],
+                 value: pulumi.Input[_builtins.str]):
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "key")
+    @key.setter
+    def key(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "key", value)
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> pulumi.Input[_builtins.str]:
+        return pulumi.get(self, "value")
+    @value.setter
+    def value(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "value", value)
+if not MYPY:
+    class RuleVmHttpArgsDict(TypedDict):
+        proxy_id: pulumi.Input[_builtins.str]
         """
-        Port to listen on the proxy
+        Id of the proxy
         """
-        port: NotRequired[pulumi.Input[_builtins.int]]
+        healths: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgsDict']]]]
         """
-        Port to listen on the vm
+        Health Check Details
+        """
+        routings: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgsDict']]]]
+        """
+        Routing configuration used to access the instances
         """
 elif False:
-    RuleVmTcpSshArgsDict: TypeAlias = Mapping[str, Any]
+    RuleVmHttpArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class RuleVmTcpSshArgs:
+class RuleVmHttpArgs:
     def __init__(__self__, *,
-                 connect_on: Optional[pulumi.Input[_builtins.int]] = None,
-                 port: Optional[pulumi.Input[_builtins.int]] = None):
+                 proxy_id: pulumi.Input[_builtins.str],
+                 healths: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]] = None,
+                 routings: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]] = None):
         """
-        :param pulumi.Input[_builtins.int] connect_on: Port to listen on the proxy
-        :param pulumi.Input[_builtins.int] port: Port to listen on the vm
+        :param pulumi.Input[_builtins.str] proxy_id: Id of the proxy
+        :param pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]] healths: Health Check Details
+        :param pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]] routings: Routing configuration used to access the instances
         """
-        if connect_on is not None:
-            pulumi.set(__self__, "connect_on", connect_on)
-        if port is not None:
-            pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "proxy_id", proxy_id)
+        if healths is not None:
+            pulumi.set(__self__, "healths", healths)
+        if routings is not None:
+            pulumi.set(__self__, "routings", routings)
     @_builtins.property
-    @pulumi.getter(name="connectOn")
-    def connect_on(self) -> Optional[pulumi.Input[_builtins.int]]:
+    @pulumi.getter(name="proxyId")
+    def proxy_id(self) -> pulumi.Input[_builtins.str]:
         """
-        Port to listen on the proxy
+        Id of the proxy
         """
-        return pulumi.get(self, "connect_on")
+        return pulumi.get(self, "proxy_id")
-    @connect_on.setter
-    def connect_on(self, value: Optional[pulumi.Input[_builtins.int]]):
-        pulumi.set(self, "connect_on", value)
+    @proxy_id.setter
+    def proxy_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "proxy_id", value)
     @_builtins.property
     @pulumi.getter
-    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
+    def healths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]]:
         """
-        Port to listen on the vm
+        Health Check Details
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "healths")
-    @port.setter
-    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
-        pulumi.set(self, "port", value)
+    @healths.setter
+    def healths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpHealthArgs']]]]):
+        pulumi.set(self, "healths", value)
+    @_builtins.property
+    @pulumi.getter
+    def routings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]]:
+        """
+        Routing configuration used to access the instances
+        """
+        return pulumi.get(self, "routings")
+    @routings.setter
+    def routings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmHttpRoutingArgs']]]]):
+        pulumi.set(self, "routings", value)
+if not MYPY:
+    class RuleVmHttpHealthArgsDict(TypedDict):
+        port: pulumi.Input[_builtins.int]
+        """
+        Health check port on the VM
+        """
+        protocol: pulumi.Input[_builtins.str]
+        """
+        Protocol can be http or https
+        """
+        path: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        API path to use for health check
+        """
+        status_code_from: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Lower limit for acceptable status code
+        """
+        status_code_to: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Upper limit for acceptable status code
+        """
+        timeout: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Health check timeout
+        """
+elif False:
+    RuleVmHttpHealthArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmHttpHealthArgs:
+    def __init__(__self__, *,
+                 port: pulumi.Input[_builtins.int],
+                 protocol: pulumi.Input[_builtins.str],
+                 path: Optional[pulumi.Input[_builtins.str]] = None,
+                 status_code_from: Optional[pulumi.Input[_builtins.int]] = None,
+                 status_code_to: Optional[pulumi.Input[_builtins.int]] = None,
+                 timeout: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] port: Health check port on the VM
+        :param pulumi.Input[_builtins.str] protocol: Protocol can be http or https
+        :param pulumi.Input[_builtins.str] path: API path to use for health check
+        :param pulumi.Input[_builtins.int] status_code_from: Lower limit for acceptable status code
+        :param pulumi.Input[_builtins.int] status_code_to: Upper limit for acceptable status code
+        :param pulumi.Input[_builtins.int] timeout: Health check timeout
+        """
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "protocol", protocol)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if status_code_from is not None:
+            pulumi.set(__self__, "status_code_from", status_code_from)
+        if status_code_to is not None:
+            pulumi.set(__self__, "status_code_to", status_code_to)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> pulumi.Input[_builtins.int]:
+        """
+        Health check port on the VM
+        """
+        return pulumi.get(self, "port")
+    @port.setter
+    def port(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "port", value)
+    @_builtins.property
+    @pulumi.getter
+    def protocol(self) -> pulumi.Input[_builtins.str]:
+        """
+        Protocol can be http or https
+        """
+        return pulumi.get(self, "protocol")
+    @protocol.setter
+    def protocol(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "protocol", value)
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        API path to use for health check
+        """
+        return pulumi.get(self, "path")
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "path", value)
+    @_builtins.property
+    @pulumi.getter(name="statusCodeFrom")
+    def status_code_from(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Lower limit for acceptable status code
+        """
+        return pulumi.get(self, "status_code_from")
+    @status_code_from.setter
+    def status_code_from(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "status_code_from", value)
+    @_builtins.property
+    @pulumi.getter(name="statusCodeTo")
+    def status_code_to(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Upper limit for acceptable status code
+        """
+        return pulumi.get(self, "status_code_to")
+    @status_code_to.setter
+    def status_code_to(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "status_code_to", value)
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Health check timeout
+        """
+        return pulumi.get(self, "timeout")
+    @timeout.setter
+    def timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "timeout", value)
+if not MYPY:
+    class RuleVmHttpRoutingArgsDict(TypedDict):
+        source_protocol: pulumi.Input[_builtins.str]
+        """
+        Source protocol of the proxy can be http or https
+        """
+        target_protocol: pulumi.Input[_builtins.str]
+        """
+        Target protocol of the instance can be http or https
+        """
+        action: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Organization Identifier for the Entity
+        """
+        source_port: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port on the proxy
+        """
+        target_port: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port on the VM
+        """
+elif False:
+    RuleVmHttpRoutingArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmHttpRoutingArgs:
+    def __init__(__self__, *,
+                 source_protocol: pulumi.Input[_builtins.str],
+                 target_protocol: pulumi.Input[_builtins.str],
+                 action: Optional[pulumi.Input[_builtins.str]] = None,
+                 source_port: Optional[pulumi.Input[_builtins.int]] = None,
+                 target_port: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.str] source_protocol: Source protocol of the proxy can be http or https
+        :param pulumi.Input[_builtins.str] target_protocol: Target protocol of the instance can be http or https
+        :param pulumi.Input[_builtins.str] action: Organization Identifier for the Entity
+        :param pulumi.Input[_builtins.int] source_port: Port on the proxy
+        :param pulumi.Input[_builtins.int] target_port: Port on the VM
+        """
+        pulumi.set(__self__, "source_protocol", source_protocol)
+        pulumi.set(__self__, "target_protocol", target_protocol)
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if source_port is not None:
+            pulumi.set(__self__, "source_port", source_port)
+        if target_port is not None:
+            pulumi.set(__self__, "target_port", target_port)
+    @_builtins.property
+    @pulumi.getter(name="sourceProtocol")
+    def source_protocol(self) -> pulumi.Input[_builtins.str]:
+        """
+        Source protocol of the proxy can be http or https
+        """
+        return pulumi.get(self, "source_protocol")
+    @source_protocol.setter
+    def source_protocol(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "source_protocol", value)
+    @_builtins.property
+    @pulumi.getter(name="targetProtocol")
+    def target_protocol(self) -> pulumi.Input[_builtins.str]:
+        """
+        Target protocol of the instance can be http or https
+        """
+        return pulumi.get(self, "target_protocol")
+    @target_protocol.setter
+    def target_protocol(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "target_protocol", value)
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Organization Identifier for the Entity
+        """
+        return pulumi.get(self, "action")
+    @action.setter
+    def action(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "action", value)
+    @_builtins.property
+    @pulumi.getter(name="sourcePort")
+    def source_port(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port on the proxy
+        """
+        return pulumi.get(self, "source_port")
+    @source_port.setter
+    def source_port(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "source_port", value)
+    @_builtins.property
+    @pulumi.getter(name="targetPort")
+    def target_port(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port on the VM
+        """
+        return pulumi.get(self, "target_port")
+    @target_port.setter
+    def target_port(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "target_port", value)
+if not MYPY:
+    class RuleVmTcpArgsDict(TypedDict):
+        proxy_id: pulumi.Input[_builtins.str]
+        """
+        Id of the Proxy
+        """
+        forward_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgsDict']]]]
+        """
+        Additional tcp forwarding rules
+        """
+        rdps: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgsDict']]]]
+        """
+        RDP configuration
+        """
+        sshes: NotRequired[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgsDict']]]]
+        """
+        SSH configuration
+        """
+elif False:
+    RuleVmTcpArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmTcpArgs:
+    def __init__(__self__, *,
+                 proxy_id: pulumi.Input[_builtins.str],
+                 forward_rules: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]] = None,
+                 rdps: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]] = None,
+                 sshes: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] proxy_id: Id of the Proxy
+        :param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]] forward_rules: Additional tcp forwarding rules
+        :param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]] rdps: RDP configuration
+        :param pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]] sshes: SSH configuration
+        """
+        pulumi.set(__self__, "proxy_id", proxy_id)
+        if forward_rules is not None:
+            pulumi.set(__self__, "forward_rules", forward_rules)
+        if rdps is not None:
+            pulumi.set(__self__, "rdps", rdps)
+        if sshes is not None:
+            pulumi.set(__self__, "sshes", sshes)
+    @_builtins.property
+    @pulumi.getter(name="proxyId")
+    def proxy_id(self) -> pulumi.Input[_builtins.str]:
+        """
+        Id of the Proxy
+        """
+        return pulumi.get(self, "proxy_id")
+    @proxy_id.setter
+    def proxy_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "proxy_id", value)
+    @_builtins.property
+    @pulumi.getter(name="forwardRules")
+    def forward_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]]:
+        """
+        Additional tcp forwarding rules
+        """
+        return pulumi.get(self, "forward_rules")
+    @forward_rules.setter
+    def forward_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpForwardRuleArgs']]]]):
+        pulumi.set(self, "forward_rules", value)
+    @_builtins.property
+    @pulumi.getter
+    def rdps(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]]:
+        """
+        RDP configuration
+        """
+        return pulumi.get(self, "rdps")
+    @rdps.setter
+    def rdps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpRdpArgs']]]]):
+        pulumi.set(self, "rdps", value)
+    @_builtins.property
+    @pulumi.getter
+    def sshes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]]:
+        """
+        SSH configuration
+        """
+        return pulumi.get(self, "sshes")
+    @sshes.setter
+    def sshes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RuleVmTcpSshArgs']]]]):
+        pulumi.set(self, "sshes", value)
+if not MYPY:
+    class RuleVmTcpForwardRuleArgsDict(TypedDict):
+        port: pulumi.Input[_builtins.int]
+        """
+        Port to listen on the vm
+        """
+        connect_on: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port to listen on the proxy
+        """
+elif False:
+    RuleVmTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmTcpForwardRuleArgs:
+    def __init__(__self__, *,
+                 port: pulumi.Input[_builtins.int],
+                 connect_on: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] port: Port to listen on the vm
+        :param pulumi.Input[_builtins.int] connect_on: Port to listen on the proxy
+        """
+        pulumi.set(__self__, "port", port)
+        if connect_on is not None:
+            pulumi.set(__self__, "connect_on", connect_on)
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> pulumi.Input[_builtins.int]:
+        """
+        Port to listen on the vm
+        """
+        return pulumi.get(self, "port")
+    @port.setter
+    def port(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "port", value)
+    @_builtins.property
+    @pulumi.getter(name="connectOn")
+    def connect_on(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port to listen on the proxy
+        """
+        return pulumi.get(self, "connect_on")
+    @connect_on.setter
+    def connect_on(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "connect_on", value)
+if not MYPY:
+    class RuleVmTcpRdpArgsDict(TypedDict):
+        connect_on: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port to listen on the proxy
+        """
+        port: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port to listen on the vm
+        """
+elif False:
+    RuleVmTcpRdpArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmTcpRdpArgs:
+    def __init__(__self__, *,
+                 connect_on: Optional[pulumi.Input[_builtins.int]] = None,
+                 port: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] connect_on: Port to listen on the proxy
+        :param pulumi.Input[_builtins.int] port: Port to listen on the vm
+        """
+        if connect_on is not None:
+            pulumi.set(__self__, "connect_on", connect_on)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+    @_builtins.property
+    @pulumi.getter(name="connectOn")
+    def connect_on(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port to listen on the proxy
+        """
+        return pulumi.get(self, "connect_on")
+    @connect_on.setter
+    def connect_on(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "connect_on", value)
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port to listen on the vm
+        """
+        return pulumi.get(self, "port")
+    @port.setter
+    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "port", value)
+if not MYPY:
+    class RuleVmTcpSshArgsDict(TypedDict):
+        connect_on: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port to listen on the proxy
+        """
+        port: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Port to listen on the vm
+        """
+elif False:
+    RuleVmTcpSshArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class RuleVmTcpSshArgs:
+    def __init__(__self__, *,
+                 connect_on: Optional[pulumi.Input[_builtins.int]] = None,
+                 port: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] connect_on: Port to listen on the proxy
+        :param pulumi.Input[_builtins.int] port: Port to listen on the vm
+        """
+        if connect_on is not None:
+            pulumi.set(__self__, "connect_on", connect_on)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+    @_builtins.property
+    @pulumi.getter(name="connectOn")
+    def connect_on(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port to listen on the proxy
+        """
+        return pulumi.get(self, "connect_on")
+    @connect_on.setter
+    def connect_on(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "connect_on", value)
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Port to listen on the vm
+        """
+        return pulumi.get(self, "port")
+    @port.setter
+    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "port", value)
+if not MYPY:
+    class ScheduleRepeatArgsDict(TypedDict):
+        days: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
+        """
+        List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
+        """
+        end_time: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
+        """
+        start_time: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
+        """
+elif False:
+    ScheduleRepeatArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class ScheduleRepeatArgs:
+    def __init__(__self__, *,
+                 days: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
+                 end_time: Optional[pulumi.Input[_builtins.str]] = None,
+                 start_time: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] days: List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
+        :param pulumi.Input[_builtins.str] end_time: Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
+        :param pulumi.Input[_builtins.str] start_time: Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
+        """
+        pulumi.set(__self__, "days", days)
+        if end_time is not None:
+            pulumi.set(__self__, "end_time", end_time)
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
+    @_builtins.property
+    @pulumi.getter
+    def days(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
+        """
+        List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
+        """
+        return pulumi.get(self, "days")
+    @days.setter
+    def days(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(self, "days", value)
+    @_builtins.property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
+        """
+        return pulumi.get(self, "end_time")
+    @end_time.setter
+    def end_time(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "end_time", value)
+    @_builtins.property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
+        """
+        return pulumi.get(self, "start_time")
+    @start_time.setter
+    def start_time(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "start_time", value)
+if not MYPY:
+    class GetAwsProxyCertificatesArgsDict(TypedDict):
+        cert_secret_id: _builtins.str
+        """
+        Certificate secret ID
+        """
+        key_secret_id: _builtins.str
+        """
+        Private key secret ID
+        """
+elif False:
+    GetAwsProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class GetAwsProxyCertificatesArgs:
+    def __init__(__self__, *,
+                 cert_secret_id: _builtins.str,
+                 key_secret_id: _builtins.str):
+        """
+        :param _builtins.str cert_secret_id: Certificate secret ID
+        :param _builtins.str key_secret_id: Private key secret ID
+        """
+        pulumi.set(__self__, "cert_secret_id", cert_secret_id)
+        pulumi.set(__self__, "key_secret_id", key_secret_id)
+    @_builtins.property
+    @pulumi.getter(name="certSecretId")
+    def cert_secret_id(self) -> _builtins.str:
+        """
+        Certificate secret ID
+        """
+        return pulumi.get(self, "cert_secret_id")
+    @cert_secret_id.setter
+    def cert_secret_id(self, value: _builtins.str):
+        pulumi.set(self, "cert_secret_id", value)
+    @_builtins.property
+    @pulumi.getter(name="keySecretId")
+    def key_secret_id(self) -> _builtins.str:
+        """
+        Private key secret ID
+        """
+        return pulumi.get(self, "key_secret_id")
+    @key_secret_id.setter
+    def key_secret_id(self, value: _builtins.str):
+        pulumi.set(self, "key_secret_id", value)
+if not MYPY:
+    class GetAzureProxyCertificatesArgsDict(TypedDict):
+        cert_secret_id: _builtins.str
+        """
+        ID of certificate secret uploaded to vault
+        """
+        key_secret_id: _builtins.str
+        """
+        ID of certificate key uploaded to vault
+        """
+elif False:
+    GetAzureProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class GetAzureProxyCertificatesArgs:
+    def __init__(__self__, *,
+                 cert_secret_id: _builtins.str,
+                 key_secret_id: _builtins.str):
+        """
+        :param _builtins.str cert_secret_id: ID of certificate secret uploaded to vault
+        :param _builtins.str key_secret_id: ID of certificate key uploaded to vault
+        """
+        pulumi.set(__self__, "cert_secret_id", cert_secret_id)
+        pulumi.set(__self__, "key_secret_id", key_secret_id)
+    @_builtins.property
+    @pulumi.getter(name="certSecretId")
+    def cert_secret_id(self) -> _builtins.str:
+        """
+        ID of certificate secret uploaded to vault
+        """
+        return pulumi.get(self, "cert_secret_id")
+    @cert_secret_id.setter
+    def cert_secret_id(self, value: _builtins.str):
+        pulumi.set(self, "cert_secret_id", value)
+    @_builtins.property
+    @pulumi.getter(name="keySecretId")
+    def key_secret_id(self) -> _builtins.str:
+        """
+        ID of certificate key uploaded to vault
+        """
+        return pulumi.get(self, "key_secret_id")
+    @key_secret_id.setter
+    def key_secret_id(self, value: _builtins.str):
+        pulumi.set(self, "key_secret_id", value)
+if not MYPY:
+    class GetGcpProxyCertificatesArgsDict(TypedDict):
+        cert_secret_id: _builtins.str
+        """
+        Certificate secret ID
+        """
+        key_secret_id: _builtins.str
+        """
+        Private key secret ID
+        """
+elif False:
+    GetGcpProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class GetGcpProxyCertificatesArgs:
+    def __init__(__self__, *,
+                 cert_secret_id: _builtins.str,
+                 key_secret_id: _builtins.str):
+        """
+        :param _builtins.str cert_secret_id: Certificate secret ID
+        :param _builtins.str key_secret_id: Private key secret ID
+        """
+        pulumi.set(__self__, "cert_secret_id", cert_secret_id)
+        pulumi.set(__self__, "key_secret_id", key_secret_id)
+    @_builtins.property
+    @pulumi.getter(name="certSecretId")
+    def cert_secret_id(self) -> _builtins.str:
+        """
+        Certificate secret ID
+        """
+        return pulumi.get(self, "cert_secret_id")
+    @cert_secret_id.setter
+    def cert_secret_id(self, value: _builtins.str):
+        pulumi.set(self, "cert_secret_id", value)
+    @_builtins.property
+    @pulumi.getter(name="keySecretId")
+    def key_secret_id(self) -> _builtins.str:
+        """
+        Private key secret ID
+        """
+        return pulumi.get(self, "key_secret_id")
+    @key_secret_id.setter
+    def key_secret_id(self, value: _builtins.str):
+        pulumi.set(self, "key_secret_id", value)
+if not MYPY:
+    class GetRuleEcsContainerArgsDict(TypedDict):
+        cluster: _builtins.str
+        """
+        Name of cluster in which service belong to
+        """
+        region: _builtins.str
+        """
+        Region of cluster
+        """
+        service: _builtins.str
+        """
+        Name of service to be onboarded
+        """
+        task_count: NotRequired[_builtins.int]
+        """
+        Desired number of tasks on warming up a rule
+        """
+elif False:
+    GetRuleEcsContainerArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class GetRuleEcsContainerArgs:
+    def __init__(__self__, *,
+                 cluster: _builtins.str,
+                 region: _builtins.str,
+                 service: _builtins.str,
+                 task_count: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str cluster: Name of cluster in which service belong to
+        :param _builtins.str region: Region of cluster
+        :param _builtins.str service: Name of service to be onboarded
+        :param _builtins.int task_count: Desired number of tasks on warming up a rule
+        """
+        pulumi.set(__self__, "cluster", cluster)
+        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "service", service)
+        if task_count is not None:
+            pulumi.set(__self__, "task_count", task_count)
+    @_builtins.property
+    @pulumi.getter
+    def cluster(self) -> _builtins.str:
+        """
+        Name of cluster in which service belong to
+        """
+        return pulumi.get(self, "cluster")
+    @cluster.setter
+    def cluster(self, value: _builtins.str):
+        pulumi.set(self, "cluster", value)
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> _builtins.str:
+        """
+        Region of cluster
+        """
+        return pulumi.get(self, "region")
+    @region.setter
+    def region(self, value: _builtins.str):
+        pulumi.set(self, "region", value)
+    @_builtins.property
+    @pulumi.getter
+    def service(self) -> _builtins.str:
+        """
+        Name of service to be onboarded
+        """
+        return pulumi.get(self, "service")
+    @service.setter
+    def service(self, value: _builtins.str):
+        pulumi.set(self, "service", value)
+    @_builtins.property
+    @pulumi.getter(name="taskCount")
+    def task_count(self) -> Optional[_builtins.int]:
+        """
+        Desired number of tasks on warming up a rule
+        """
+        return pulumi.get(self, "task_count")
+    @task_count.setter
+    def task_count(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "task_count", value)
 if not MYPY:
-    class ScheduleRepeatArgsDict(TypedDict):
-        days: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
-        """
-        List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
-        """
-        end_time: NotRequired[pulumi.Input[_builtins.str]]
+    class GetRuleEcsDependArgsDict(TypedDict):
+        rule_id: _builtins.int
         """
-        Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
+        Rule id of the dependent rule
         """
-        start_time: NotRequired[pulumi.Input[_builtins.str]]
+        delay_in_sec: NotRequired[_builtins.int]
         """
-        Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
+        Number of seconds the rule should wait after warming up the dependent rule
         """
 elif False:
-    ScheduleRepeatArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleEcsDependArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class ScheduleRepeatArgs:
+class GetRuleEcsDependArgs:
     def __init__(__self__, *,
-                 days: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
-                 end_time: Optional[pulumi.Input[_builtins.str]] = None,
-                 start_time: Optional[pulumi.Input[_builtins.str]] = None):
+                 rule_id: _builtins.int,
+                 delay_in_sec: Optional[_builtins.int] = None):
         """
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] days: List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
-        :param pulumi.Input[_builtins.str] end_time: Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
-        :param pulumi.Input[_builtins.str] start_time: Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
+        :param _builtins.int rule_id: Rule id of the dependent rule
+        :param _builtins.int delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
         """
-        pulumi.set(__self__, "days", days)
-        if end_time is not None:
-            pulumi.set(__self__, "end_time", end_time)
-        if start_time is not None:
-            pulumi.set(__self__, "start_time", start_time)
+        pulumi.set(__self__, "rule_id", rule_id)
+        if delay_in_sec is not None:
+            pulumi.set(__self__, "delay_in_sec", delay_in_sec)
     @_builtins.property
-    @pulumi.getter
-    def days(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
+    @pulumi.getter(name="ruleId")
+    def rule_id(self) -> _builtins.int:
         """
-        List of days on which schedule need to be active. Valid values are SUN, MON, TUE, WED, THU, FRI and SAT.
+        Rule id of the dependent rule
         """
-        return pulumi.get(self, "days")
+        return pulumi.get(self, "rule_id")
-    @days.setter
-    def days(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
-        pulumi.set(self, "days", value)
+    @rule_id.setter
+    def rule_id(self, value: _builtins.int):
+        pulumi.set(self, "rule_id", value)
     @_builtins.property
-    @pulumi.getter(name="endTime")
-    def end_time(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter(name="delayInSec")
+    def delay_in_sec(self) -> Optional[_builtins.int]:
         """
-        Ending time of schedule action on the day. Defaults to 24:00Hrs unless specified. Accepted format is HH:MM. Eg : 20:00 for 8pm
+        Number of seconds the rule should wait after warming up the dependent rule
         """
-        return pulumi.get(self, "end_time")
+        return pulumi.get(self, "delay_in_sec")
-    @end_time.setter
-    def end_time(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "end_time", value)
+    @delay_in_sec.setter
+    def delay_in_sec(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "delay_in_sec", value)
+if not MYPY:
+    class GetRuleEcsHttpArgsDict(TypedDict):
+        proxy_id: _builtins.str
+        """
+        Id of the proxy
+        """
+elif False:
+    GetRuleEcsHttpArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class GetRuleEcsHttpArgs:
+    def __init__(__self__, *,
+                 proxy_id: _builtins.str):
+        """
+        :param _builtins.str proxy_id: Id of the proxy
+        """
+        pulumi.set(__self__, "proxy_id", proxy_id)
     @_builtins.property
-    @pulumi.getter(name="startTime")
-    def start_time(self) -> Optional[pulumi.Input[_builtins.str]]:
+    @pulumi.getter(name="proxyId")
+    def proxy_id(self) -> _builtins.str:
         """
-        Starting time of schedule action on the day. Defaults to 00:00Hrs unless specified. Accepted format is HH:MM. Eg : 13:15 for 01:15pm
+        Id of the proxy
         """
-        return pulumi.get(self, "start_time")
+        return pulumi.get(self, "proxy_id")
-    @start_time.setter
-    def start_time(self, value: Optional[pulumi.Input[_builtins.str]]):
-        pulumi.set(self, "start_time", value)
+    @proxy_id.setter
+    def proxy_id(self, value: _builtins.str):
+        pulumi.set(self, "proxy_id", value)
 if not MYPY:
-    class GetAwsProxyCertificatesArgsDict(TypedDict):
-        cert_secret_id: _builtins.str
+    class GetRuleRdsDatabaseArgsDict(TypedDict):
+        id: _builtins.str
         """
-        Certificate secret ID
+        ID of the database
         """
-        key_secret_id: _builtins.str
+        region: _builtins.str
         """
-        Private key secret ID
+        Region to which database belong to
         """
 elif False:
-    GetAwsProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleRdsDatabaseArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetAwsProxyCertificatesArgs:
+class GetRuleRdsDatabaseArgs:
     def __init__(__self__, *,
-                 cert_secret_id: _builtins.str,
-                 key_secret_id: _builtins.str):
+                 id: _builtins.str,
+                 region: _builtins.str):
         """
-        :param _builtins.str cert_secret_id: Certificate secret ID
-        :param _builtins.str key_secret_id: Private key secret ID
+        :param _builtins.str id: ID of the database
+        :param _builtins.str region: Region to which database belong to
         """
-        pulumi.set(__self__, "cert_secret_id", cert_secret_id)
-        pulumi.set(__self__, "key_secret_id", key_secret_id)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "region", region)
     @_builtins.property
-    @pulumi.getter(name="certSecretId")
-    def cert_secret_id(self) -> _builtins.str:
+    @pulumi.getter
+    def id(self) -> _builtins.str:
         """
-        Certificate secret ID
+        ID of the database
         """
-        return pulumi.get(self, "cert_secret_id")
+        return pulumi.get(self, "id")
-    @cert_secret_id.setter
-    def cert_secret_id(self, value: _builtins.str):
-        pulumi.set(self, "cert_secret_id", value)
+    @id.setter
+    def id(self, value: _builtins.str):
+        pulumi.set(self, "id", value)
     @_builtins.property
-    @pulumi.getter(name="keySecretId")
-    def key_secret_id(self) -> _builtins.str:
+    @pulumi.getter
+    def region(self) -> _builtins.str:
         """
-        Private key secret ID
+        Region to which database belong to
         """
-        return pulumi.get(self, "key_secret_id")
+        return pulumi.get(self, "region")
-    @key_secret_id.setter
-    def key_secret_id(self, value: _builtins.str):
-        pulumi.set(self, "key_secret_id", value)
+    @region.setter
+    def region(self, value: _builtins.str):
+        pulumi.set(self, "region", value)
 if not MYPY:
-    class GetAzureProxyCertificatesArgsDict(TypedDict):
-        cert_secret_id: _builtins.str
+    class GetRuleRdsDependArgsDict(TypedDict):
+        rule_id: _builtins.int
         """
-        ID of certificate secret uploaded to vault
+        Rule id of the dependent rule
         """
-        key_secret_id: _builtins.str
+        delay_in_sec: NotRequired[_builtins.int]
         """
-        ID of certificate key uploaded to vault
+        Number of seconds the rule should wait after warming up the dependent rule
         """
 elif False:
-    GetAzureProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleRdsDependArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetAzureProxyCertificatesArgs:
+class GetRuleRdsDependArgs:
     def __init__(__self__, *,
-                 cert_secret_id: _builtins.str,
-                 key_secret_id: _builtins.str):
+                 rule_id: _builtins.int,
+                 delay_in_sec: Optional[_builtins.int] = None):
         """
-        :param _builtins.str cert_secret_id: ID of certificate secret uploaded to vault
-        :param _builtins.str key_secret_id: ID of certificate key uploaded to vault
+        :param _builtins.int rule_id: Rule id of the dependent rule
+        :param _builtins.int delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
         """
-        pulumi.set(__self__, "cert_secret_id", cert_secret_id)
-        pulumi.set(__self__, "key_secret_id", key_secret_id)
+        pulumi.set(__self__, "rule_id", rule_id)
+        if delay_in_sec is not None:
+            pulumi.set(__self__, "delay_in_sec", delay_in_sec)
     @_builtins.property
-    @pulumi.getter(name="certSecretId")
-    def cert_secret_id(self) -> _builtins.str:
+    @pulumi.getter(name="ruleId")
+    def rule_id(self) -> _builtins.int:
         """
-        ID of certificate secret uploaded to vault
+        Rule id of the dependent rule
         """
-        return pulumi.get(self, "cert_secret_id")
+        return pulumi.get(self, "rule_id")
-    @cert_secret_id.setter
-    def cert_secret_id(self, value: _builtins.str):
-        pulumi.set(self, "cert_secret_id", value)
+    @rule_id.setter
+    def rule_id(self, value: _builtins.int):
+        pulumi.set(self, "rule_id", value)
     @_builtins.property
-    @pulumi.getter(name="keySecretId")
-    def key_secret_id(self) -> _builtins.str:
+    @pulumi.getter(name="delayInSec")
+    def delay_in_sec(self) -> Optional[_builtins.int]:
         """
-        ID of certificate key uploaded to vault
+        Number of seconds the rule should wait after warming up the dependent rule
         """
-        return pulumi.get(self, "key_secret_id")
+        return pulumi.get(self, "delay_in_sec")
-    @key_secret_id.setter
-    def key_secret_id(self, value: _builtins.str):
-        pulumi.set(self, "key_secret_id", value)
+    @delay_in_sec.setter
+    def delay_in_sec(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "delay_in_sec", value)
 if not MYPY:
-    class GetGcpProxyCertificatesArgsDict(TypedDict):
-        cert_secret_id: _builtins.str
+    class GetRuleRdsTcpArgsDict(TypedDict):
+        proxy_id: _builtins.str
         """
-        Certificate secret ID
+        Id of the Proxy
         """
-        key_secret_id: _builtins.str
+        forward_rules: NotRequired[Sequence['GetRuleRdsTcpForwardRuleArgsDict']]
         """
-        Private key secret ID
+        Additional tcp forwarding rules
         """
 elif False:
-    GetGcpProxyCertificatesArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleRdsTcpArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetGcpProxyCertificatesArgs:
+class GetRuleRdsTcpArgs:
     def __init__(__self__, *,
-                 cert_secret_id: _builtins.str,
-                 key_secret_id: _builtins.str):
+                 proxy_id: _builtins.str,
+                 forward_rules: Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']] = None):
         """
-        :param _builtins.str cert_secret_id: Certificate secret ID
-        :param _builtins.str key_secret_id: Private key secret ID
+        :param _builtins.str proxy_id: Id of the Proxy
+        :param Sequence['GetRuleRdsTcpForwardRuleArgs'] forward_rules: Additional tcp forwarding rules
         """
-        pulumi.set(__self__, "cert_secret_id", cert_secret_id)
-        pulumi.set(__self__, "key_secret_id", key_secret_id)
+        pulumi.set(__self__, "proxy_id", proxy_id)
+        if forward_rules is not None:
+            pulumi.set(__self__, "forward_rules", forward_rules)
     @_builtins.property
-    @pulumi.getter(name="certSecretId")
-    def cert_secret_id(self) -> _builtins.str:
+    @pulumi.getter(name="proxyId")
+    def proxy_id(self) -> _builtins.str:
         """
-        Certificate secret ID
+        Id of the Proxy
         """
-        return pulumi.get(self, "cert_secret_id")
+        return pulumi.get(self, "proxy_id")
-    @cert_secret_id.setter
-    def cert_secret_id(self, value: _builtins.str):
-        pulumi.set(self, "cert_secret_id", value)
+    @proxy_id.setter
+    def proxy_id(self, value: _builtins.str):
+        pulumi.set(self, "proxy_id", value)
     @_builtins.property
-    @pulumi.getter(name="keySecretId")
-    def key_secret_id(self) -> _builtins.str:
+    @pulumi.getter(name="forwardRules")
+    def forward_rules(self) -> Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']]:
         """
-        Private key secret ID
+        Additional tcp forwarding rules
         """
-        return pulumi.get(self, "key_secret_id")
+        return pulumi.get(self, "forward_rules")
-    @key_secret_id.setter
-    def key_secret_id(self, value: _builtins.str):
-        pulumi.set(self, "key_secret_id", value)
+    @forward_rules.setter
+    def forward_rules(self, value: Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']]):
+        pulumi.set(self, "forward_rules", value)
 if not MYPY:
-    class GetRuleEcsContainerArgsDict(TypedDict):
-        cluster: _builtins.str
-        """
-        Name of cluster in which service belong to
-        """
-        region: _builtins.str
-        """
-        Region of cluster
-        """
-        service: _builtins.str
+    class GetRuleRdsTcpForwardRuleArgsDict(TypedDict):
+        port: _builtins.int
         """
-        Name of service to be onboarded
+        Port to listen on the vm
         """
-        task_count: NotRequired[_builtins.int]
+        connect_on: NotRequired[_builtins.int]
         """
-        Desired number of tasks on warming up a rule
+        Port to listen on the proxy
         """
 elif False:
-    GetRuleEcsContainerArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleRdsTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetRuleEcsContainerArgs:
+class GetRuleRdsTcpForwardRuleArgs:
     def __init__(__self__, *,
-                 cluster: _builtins.str,
-                 region: _builtins.str,
-                 service: _builtins.str,
-                 task_count: Optional[_builtins.int] = None):
-        """
-        :param _builtins.str cluster: Name of cluster in which service belong to
-        :param _builtins.str region: Region of cluster
-        :param _builtins.str service: Name of service to be onboarded
-        :param _builtins.int task_count: Desired number of tasks on warming up a rule
-        """
-        pulumi.set(__self__, "cluster", cluster)
-        pulumi.set(__self__, "region", region)
-        pulumi.set(__self__, "service", service)
-        if task_count is not None:
-            pulumi.set(__self__, "task_count", task_count)
-    @_builtins.property
-    @pulumi.getter
-    def cluster(self) -> _builtins.str:
-        """
-        Name of cluster in which service belong to
-        """
-        return pulumi.get(self, "cluster")
-    @cluster.setter
-    def cluster(self, value: _builtins.str):
-        pulumi.set(self, "cluster", value)
-    @_builtins.property
-    @pulumi.getter
-    def region(self) -> _builtins.str:
+                 port: _builtins.int,
+                 connect_on: Optional[_builtins.int] = None):
         """
-        Region of cluster
+        :param _builtins.int port: Port to listen on the vm
+        :param _builtins.int connect_on: Port to listen on the proxy
         """
-        return pulumi.get(self, "region")
-    @region.setter
-    def region(self, value: _builtins.str):
-        pulumi.set(self, "region", value)
+        pulumi.set(__self__, "port", port)
+        if connect_on is not None:
+            pulumi.set(__self__, "connect_on", connect_on)
     @_builtins.property
     @pulumi.getter
-    def service(self) -> _builtins.str:
+    def port(self) -> _builtins.int:
         """
-        Name of service to be onboarded
+        Port to listen on the vm
         """
-        return pulumi.get(self, "service")
+        return pulumi.get(self, "port")
-    @service.setter
-    def service(self, value: _builtins.str):
-        pulumi.set(self, "service", value)
+    @port.setter
+    def port(self, value: _builtins.int):
+        pulumi.set(self, "port", value)
     @_builtins.property
-    @pulumi.getter(name="taskCount")
-    def task_count(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="connectOn")
+    def connect_on(self) -> Optional[_builtins.int]:
         """
-        Desired number of tasks on warming up a rule
+        Port to listen on the proxy
         """
-        return pulumi.get(self, "task_count")
+        return pulumi.get(self, "connect_on")
-    @task_count.setter
-    def task_count(self, value: Optional[_builtins.int]):
-        pulumi.set(self, "task_count", value)
+    @connect_on.setter
+    def connect_on(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "connect_on", value)
 if not MYPY:
-    class GetRuleEcsDependArgsDict(TypedDict):
+    class GetRuleScaleGroupDependArgsDict(TypedDict):
         rule_id: _builtins.int
         """
         Rule id of the dependent rule
@@ -1679,10 +2512,10 @@ if not MYPY:
         Number of seconds the rule should wait after warming up the dependent rule
         """
 elif False:
-    GetRuleEcsDependArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleScaleGroupDependArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetRuleEcsDependArgs:
+class GetRuleScaleGroupDependArgs:
     def __init__(__self__, *,
                  rule_id: _builtins.int,
                  delay_in_sec: Optional[_builtins.int] = None):
@@ -1720,237 +2553,480 @@ class GetRuleEcsDependArgs:
 if not MYPY:
-    class GetRuleEcsHttpArgsDict(TypedDict):
+    class GetRuleScaleGroupHttpArgsDict(TypedDict):
         proxy_id: _builtins.str
         """
         Id of the proxy
         """
+        healths: NotRequired[Sequence['GetRuleScaleGroupHttpHealthArgsDict']]
+        """
+        Health Check Details
+        """
+        routings: NotRequired[Sequence['GetRuleScaleGroupHttpRoutingArgsDict']]
+        """
+        Routing configuration used to access the scaling group
+        """
 elif False:
-    GetRuleEcsHttpArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleScaleGroupHttpArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetRuleEcsHttpArgs:
+class GetRuleScaleGroupHttpArgs:
     def __init__(__self__, *,
-                 proxy_id: _builtins.str):
+                 proxy_id: _builtins.str,
+                 healths: Optional[Sequence['GetRuleScaleGroupHttpHealthArgs']] = None,
+                 routings: Optional[Sequence['GetRuleScaleGroupHttpRoutingArgs']] = None):
+        """
+        :param _builtins.str proxy_id: Id of the proxy
+        :param Sequence['GetRuleScaleGroupHttpHealthArgs'] healths: Health Check Details
+        :param Sequence['GetRuleScaleGroupHttpRoutingArgs'] routings: Routing configuration used to access the scaling group
+        """
+        pulumi.set(__self__, "proxy_id", proxy_id)
+        if healths is not None:
+            pulumi.set(__self__, "healths", healths)
+        if routings is not None:
+            pulumi.set(__self__, "routings", routings)
+    @_builtins.property
+    @pulumi.getter(name="proxyId")
+    def proxy_id(self) -> _builtins.str:
+        """
+        Id of the proxy
+        """
+        return pulumi.get(self, "proxy_id")
+    @proxy_id.setter
+    def proxy_id(self, value: _builtins.str):
+        pulumi.set(self, "proxy_id", value)
+    @_builtins.property
+    @pulumi.getter
+    def healths(self) -> Optional[Sequence['GetRuleScaleGroupHttpHealthArgs']]:
+        """
+        Health Check Details
+        """
+        return pulumi.get(self, "healths")
+    @healths.setter
+    def healths(self, value: Optional[Sequence['GetRuleScaleGroupHttpHealthArgs']]):
+        pulumi.set(self, "healths", value)
+    @_builtins.property
+    @pulumi.getter
+    def routings(self) -> Optional[Sequence['GetRuleScaleGroupHttpRoutingArgs']]:
+        """
+        Routing configuration used to access the scaling group
+        """
+        return pulumi.get(self, "routings")
+    @routings.setter
+    def routings(self, value: Optional[Sequence['GetRuleScaleGroupHttpRoutingArgs']]):
+        pulumi.set(self, "routings", value)
+if not MYPY:
+    class GetRuleScaleGroupHttpHealthArgsDict(TypedDict):
+        port: _builtins.int
+        """
+        Health check port on the VM
+        """
+        protocol: _builtins.str
+        """
+        Protocol can be http or https
+        """
+        path: NotRequired[_builtins.str]
+        """
+        API path to use for health check
+        """
+        status_code_from: NotRequired[_builtins.int]
+        """
+        Lower limit for acceptable status code
+        """
+        status_code_to: NotRequired[_builtins.int]
+        """
+        Upper limit for acceptable status code
+        """
+        timeout: NotRequired[_builtins.int]
+        """
+        Health check timeout
+        """
+elif False:
+    GetRuleScaleGroupHttpHealthArgsDict: TypeAlias = Mapping[str, Any]
+@pulumi.input_type
+class GetRuleScaleGroupHttpHealthArgs:
+    def __init__(__self__, *,
+                 port: _builtins.int,
+                 protocol: _builtins.str,
+                 path: Optional[_builtins.str] = None,
+                 status_code_from: Optional[_builtins.int] = None,
+                 status_code_to: Optional[_builtins.int] = None,
+                 timeout: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int port: Health check port on the VM
+        :param _builtins.str protocol: Protocol can be http or https
+        :param _builtins.str path: API path to use for health check
+        :param _builtins.int status_code_from: Lower limit for acceptable status code
+        :param _builtins.int status_code_to: Upper limit for acceptable status code
+        :param _builtins.int timeout: Health check timeout
+        """
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "protocol", protocol)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if status_code_from is not None:
+            pulumi.set(__self__, "status_code_from", status_code_from)
+        if status_code_to is not None:
+            pulumi.set(__self__, "status_code_to", status_code_to)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+    @_builtins.property
+    @pulumi.getter
+    def port(self) -> _builtins.int:
+        """
+        Health check port on the VM
+        """
+        return pulumi.get(self, "port")
+    @port.setter
+    def port(self, value: _builtins.int):
+        pulumi.set(self, "port", value)
+    @_builtins.property
+    @pulumi.getter
+    def protocol(self) -> _builtins.str:
+        """
+        Protocol can be http or https
+        """
+        return pulumi.get(self, "protocol")
+    @protocol.setter
+    def protocol(self, value: _builtins.str):
+        pulumi.set(self, "protocol", value)
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[_builtins.str]:
+        """
+        API path to use for health check
+        """
+        return pulumi.get(self, "path")
+    @path.setter
+    def path(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "path", value)
+    @_builtins.property
+    @pulumi.getter(name="statusCodeFrom")
+    def status_code_from(self) -> Optional[_builtins.int]:
+        """
+        Lower limit for acceptable status code
+        """
+        return pulumi.get(self, "status_code_from")
+    @status_code_from.setter
+    def status_code_from(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "status_code_from", value)
+    @_builtins.property
+    @pulumi.getter(name="statusCodeTo")
+    def status_code_to(self) -> Optional[_builtins.int]:
         """
-        :param _builtins.str proxy_id: Id of the proxy
+        Upper limit for acceptable status code
         """
-        pulumi.set(__self__, "proxy_id", proxy_id)
+        return pulumi.get(self, "status_code_to")
+    @status_code_to.setter
+    def status_code_to(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "status_code_to", value)
     @_builtins.property
-    @pulumi.getter(name="proxyId")
-    def proxy_id(self) -> _builtins.str:
+    @pulumi.getter
+    def timeout(self) -> Optional[_builtins.int]:
         """
-        Id of the proxy
+        Health check timeout
         """
-        return pulumi.get(self, "proxy_id")
+        return pulumi.get(self, "timeout")
-    @proxy_id.setter
-    def proxy_id(self, value: _builtins.str):
-        pulumi.set(self, "proxy_id", value)
+    @timeout.setter
+    def timeout(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "timeout", value)
 if not MYPY:
-    class GetRuleRdsDatabaseArgsDict(TypedDict):
-        id: _builtins.str
+    class GetRuleScaleGroupHttpRoutingArgsDict(TypedDict):
+        source_protocol: _builtins.str
         """
-        ID of the database
+        Source protocol of the proxy can be http or https
         """
-        region: _builtins.str
+        target_protocol: _builtins.str
         """
-        Region to which database belong to
+        Target protocol of the instance can be http or https
+        """
+        action: NotRequired[_builtins.str]
+        """
+        Organization Identifier for the Entity
+        """
+        source_port: NotRequired[_builtins.int]
+        """
+        Port on the proxy
+        """
+        target_port: NotRequired[_builtins.int]
+        """
+        Port on the VM
         """
 elif False:
-    GetRuleRdsDatabaseArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleScaleGroupHttpRoutingArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetRuleRdsDatabaseArgs:
+class GetRuleScaleGroupHttpRoutingArgs:
     def __init__(__self__, *,
-                 id: _builtins.str,
-                 region: _builtins.str):
+                 source_protocol: _builtins.str,
+                 target_protocol: _builtins.str,
+                 action: Optional[_builtins.str] = None,
+                 source_port: Optional[_builtins.int] = None,
+                 target_port: Optional[_builtins.int] = None):
         """
-        :param _builtins.str id: ID of the database
-        :param _builtins.str region: Region to which database belong to
+        :param _builtins.str source_protocol: Source protocol of the proxy can be http or https
+        :param _builtins.str target_protocol: Target protocol of the instance can be http or https
+        :param _builtins.str action: Organization Identifier for the Entity
+        :param _builtins.int source_port: Port on the proxy
+        :param _builtins.int target_port: Port on the VM
         """
-        pulumi.set(__self__, "id", id)
-        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "source_protocol", source_protocol)
+        pulumi.set(__self__, "target_protocol", target_protocol)
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if source_port is not None:
+            pulumi.set(__self__, "source_port", source_port)
+        if target_port is not None:
+            pulumi.set(__self__, "target_port", target_port)
     @_builtins.property
-    @pulumi.getter
-    def id(self) -> _builtins.str:
+    @pulumi.getter(name="sourceProtocol")
+    def source_protocol(self) -> _builtins.str:
         """
-        ID of the database
+        Source protocol of the proxy can be http or https
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "source_protocol")
-    @id.setter
-    def id(self, value: _builtins.str):
-        pulumi.set(self, "id", value)
+    @source_protocol.setter
+    def source_protocol(self, value: _builtins.str):
+        pulumi.set(self, "source_protocol", value)
     @_builtins.property
-    @pulumi.getter
-    def region(self) -> _builtins.str:
+    @pulumi.getter(name="targetProtocol")
+    def target_protocol(self) -> _builtins.str:
         """
-        Region to which database belong to
+        Target protocol of the instance can be http or https
         """
-        return pulumi.get(self, "region")
-    @region.setter
-    def region(self, value: _builtins.str):
-        pulumi.set(self, "region", value)
+        return pulumi.get(self, "target_protocol")
+    @target_protocol.setter
+    def target_protocol(self, value: _builtins.str):
+        pulumi.set(self, "target_protocol", value)
-if not MYPY:
-    class GetRuleRdsDependArgsDict(TypedDict):
-        rule_id: _builtins.int
-        """
-        Rule id of the dependent rule
-        """
-        delay_in_sec: NotRequired[_builtins.int]
+    @_builtins.property
+    @pulumi.getter
+    def action(self) -> Optional[_builtins.str]:
         """
-        Number of seconds the rule should wait after warming up the dependent rule
+        Organization Identifier for the Entity
         """
-elif False:
-    GetRuleRdsDependArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "action")
-@pulumi.input_type
-class GetRuleRdsDependArgs:
-    def __init__(__self__, *,
-                 rule_id: _builtins.int,
-                 delay_in_sec: Optional[_builtins.int] = None):
-        """
-        :param _builtins.int rule_id: Rule id of the dependent rule
-        :param _builtins.int delay_in_sec: Number of seconds the rule should wait after warming up the dependent rule
-        """
-        pulumi.set(__self__, "rule_id", rule_id)
-        if delay_in_sec is not None:
-            pulumi.set(__self__, "delay_in_sec", delay_in_sec)
+    @action.setter
+    def action(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "action", value)
     @_builtins.property
-    @pulumi.getter(name="ruleId")
-    def rule_id(self) -> _builtins.int:
+    @pulumi.getter(name="sourcePort")
+    def source_port(self) -> Optional[_builtins.int]:
         """
-        Rule id of the dependent rule
+        Port on the proxy
         """
-        return pulumi.get(self, "rule_id")
+        return pulumi.get(self, "source_port")
-    @rule_id.setter
-    def rule_id(self, value: _builtins.int):
-        pulumi.set(self, "rule_id", value)
+    @source_port.setter
+    def source_port(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "source_port", value)
     @_builtins.property
-    @pulumi.getter(name="delayInSec")
-    def delay_in_sec(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="targetPort")
+    def target_port(self) -> Optional[_builtins.int]:
         """
-        Number of seconds the rule should wait after warming up the dependent rule
+        Port on the VM
         """
-        return pulumi.get(self, "delay_in_sec")
+        return pulumi.get(self, "target_port")
-    @delay_in_sec.setter
-    def delay_in_sec(self, value: Optional[_builtins.int]):
-        pulumi.set(self, "delay_in_sec", value)
+    @target_port.setter
+    def target_port(self, value: Optional[_builtins.int]):
+        pulumi.set(self, "target_port", value)
 if not MYPY:
-    class GetRuleRdsTcpArgsDict(TypedDict):
-        proxy_id: _builtins.str
+    class GetRuleScaleGroupScaleGroupArgsDict(TypedDict):
+        desired: _builtins.int
         """
-        Id of the Proxy
+        Desired capacity of the Scaling Group
         """
-        forward_rules: NotRequired[Sequence['GetRuleRdsTcpForwardRuleArgsDict']]
+        id: _builtins.str
         """
-        Additional tcp forwarding rules
+        ID of the Scaling Group
+        """
+        max: _builtins.int
+        """
+        Maximum capacity of the Scaling Group
+        """
+        min: _builtins.int
+        """
+        Minimum capacity of the Scaling Group
+        """
+        name: _builtins.str
+        """
+        Name of the Scaling Group
+        """
+        on_demand: _builtins.int
+        """
+        On-demand capacity of the Scaling Group
+        """
+        region: NotRequired[_builtins.str]
+        """
+        Region of the Scaling Group
+        """
+        zone: NotRequired[_builtins.str]
+        """
+        Zone of the Scaling Group. Needed for GCP only
         """
 elif False:
-    GetRuleRdsTcpArgsDict: TypeAlias = Mapping[str, Any]
+    GetRuleScaleGroupScaleGroupArgsDict: TypeAlias = Mapping[str, Any]
 @pulumi.input_type
-class GetRuleRdsTcpArgs:
+class GetRuleScaleGroupScaleGroupArgs:
     def __init__(__self__, *,
-                 proxy_id: _builtins.str,
-                 forward_rules: Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']] = None):
+                 desired: _builtins.int,
+                 id: _builtins.str,
+                 max: _builtins.int,
+                 min: _builtins.int,
+                 name: _builtins.str,
+                 on_demand: _builtins.int,
+                 region: Optional[_builtins.str] = None,
+                 zone: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int desired: Desired capacity of the Scaling Group
+        :param _builtins.str id: ID of the Scaling Group
+        :param _builtins.int max: Maximum capacity of the Scaling Group
+        :param _builtins.int min: Minimum capacity of the Scaling Group
+        :param _builtins.str name: Name of the Scaling Group
+        :param _builtins.int on_demand: On-demand capacity of the Scaling Group
+        :param _builtins.str region: Region of the Scaling Group
+        :param _builtins.str zone: Zone of the Scaling Group. Needed for GCP only
+        """
+        pulumi.set(__self__, "desired", desired)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "max", max)
+        pulumi.set(__self__, "min", min)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "on_demand", on_demand)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
+    @_builtins.property
+    @pulumi.getter
+    def desired(self) -> _builtins.int:
         """
-        :param _builtins.str proxy_id: Id of the Proxy
-        :param Sequence['GetRuleRdsTcpForwardRuleArgs'] forward_rules: Additional tcp forwarding rules
+        Desired capacity of the Scaling Group
         """
-        pulumi.set(__self__, "proxy_id", proxy_id)
-        if forward_rules is not None:
-            pulumi.set(__self__, "forward_rules", forward_rules)
+        return pulumi.get(self, "desired")
+    @desired.setter
+    def desired(self, value: _builtins.int):
+        pulumi.set(self, "desired", value)
     @_builtins.property
-    @pulumi.getter(name="proxyId")
-    def proxy_id(self) -> _builtins.str:
+    @pulumi.getter
+    def id(self) -> _builtins.str:
         """
-        Id of the Proxy
+        ID of the Scaling Group
         """
-        return pulumi.get(self, "proxy_id")
+        return pulumi.get(self, "id")
-    @proxy_id.setter
-    def proxy_id(self, value: _builtins.str):
-        pulumi.set(self, "proxy_id", value)
+    @id.setter
+    def id(self, value: _builtins.str):
+        pulumi.set(self, "id", value)
     @_builtins.property
-    @pulumi.getter(name="forwardRules")
-    def forward_rules(self) -> Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']]:
+    @pulumi.getter
+    def max(self) -> _builtins.int:
         """
-        Additional tcp forwarding rules
+        Maximum capacity of the Scaling Group
         """
-        return pulumi.get(self, "forward_rules")
-    @forward_rules.setter
-    def forward_rules(self, value: Optional[Sequence['GetRuleRdsTcpForwardRuleArgs']]):
-        pulumi.set(self, "forward_rules", value)
+        return pulumi.get(self, "max")
+    @max.setter
+    def max(self, value: _builtins.int):
+        pulumi.set(self, "max", value)
-if not MYPY:
-    class GetRuleRdsTcpForwardRuleArgsDict(TypedDict):
-        port: _builtins.int
+    @_builtins.property
+    @pulumi.getter
+    def min(self) -> _builtins.int:
         """
-        Port to listen on the vm
+        Minimum capacity of the Scaling Group
         """
-        connect_on: NotRequired[_builtins.int]
+        return pulumi.get(self, "min")
+    @min.setter
+    def min(self, value: _builtins.int):
+        pulumi.set(self, "min", value)
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
         """
-        Port to listen on the proxy
+        Name of the Scaling Group
         """
-elif False:
-    GetRuleRdsTcpForwardRuleArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "name")
-@pulumi.input_type
-class GetRuleRdsTcpForwardRuleArgs:
-    def __init__(__self__, *,
-                 port: _builtins.int,
-                 connect_on: Optional[_builtins.int] = None):
+    @name.setter
+    def name(self, value: _builtins.str):
+        pulumi.set(self, "name", value)
+    @_builtins.property
+    @pulumi.getter(name="onDemand")
+    def on_demand(self) -> _builtins.int:
         """
-        :param _builtins.int port: Port to listen on the vm
-        :param _builtins.int connect_on: Port to listen on the proxy
+        On-demand capacity of the Scaling Group
         """
-        pulumi.set(__self__, "port", port)
-        if connect_on is not None:
-            pulumi.set(__self__, "connect_on", connect_on)
+        return pulumi.get(self, "on_demand")
+    @on_demand.setter
+    def on_demand(self, value: _builtins.int):
+        pulumi.set(self, "on_demand", value)
     @_builtins.property
     @pulumi.getter
-    def port(self) -> _builtins.int:
+    def region(self) -> Optional[_builtins.str]:
         """
-        Port to listen on the vm
+        Region of the Scaling Group
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "region")
-    @port.setter
-    def port(self, value: _builtins.int):
-        pulumi.set(self, "port", value)
+    @region.setter
+    def region(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "region", value)
     @_builtins.property
-    @pulumi.getter(name="connectOn")
-    def connect_on(self) -> Optional[_builtins.int]:
+    @pulumi.getter
+    def zone(self) -> Optional[_builtins.str]:
         """
-        Port to listen on the proxy
+        Zone of the Scaling Group. Needed for GCP only
         """
-        return pulumi.get(self, "connect_on")
+        return pulumi.get(self, "zone")
-    @connect_on.setter
-    def connect_on(self, value: Optional[_builtins.int]):
-        pulumi.set(self, "connect_on", value)
+    @zone.setter
+    def zone(self, value: Optional[_builtins.str]):
+        pulumi.set(self, "zone", value)
 if not MYPY:

pulumi-harness 0.9.0a1760076204__py3-none-any.whl → 0.10.0a1764049859__py3-none-any.whl

pulumi-harness 0.9.0a1760076204py3-none-any.whl → 0.10.0a1764049859py3-none-any.whl