pulumi-alicloud 3.88.0a1761888283__py3-none-any.whl → 3.89.0a1761974293__py3-none-any.whl

pulumi_alicloud/esa/_inputs.py

@@ -19,6 +19,16 @@ __all__ = [
     'HttpRequestHeaderModificationRuleRequestHeaderModificationArgsDict',
     'HttpResponseHeaderModificationRuleResponseHeaderModificationArgs',
     'HttpResponseHeaderModificationRuleResponseHeaderModificationArgsDict',
+    'LoadBalancerAdaptiveRoutingArgs',
+    'LoadBalancerAdaptiveRoutingArgsDict',
+    'LoadBalancerMonitorArgs',
+    'LoadBalancerMonitorArgsDict',
+    'LoadBalancerRandomSteeringArgs',
+    'LoadBalancerRandomSteeringArgsDict',
+    'LoadBalancerRuleArgs',
+    'LoadBalancerRuleArgsDict',
+    'LoadBalancerRuleFixedResponseArgs',
+    'LoadBalancerRuleFixedResponseArgsDict',
     'OriginPoolOriginArgs',
     'OriginPoolOriginArgsDict',
     'OriginPoolOriginAuthConfArgs',
@@ -245,6 +255,607 @@ class HttpResponseHeaderModificationRuleResponseHeaderModificationArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class LoadBalancerAdaptiveRoutingArgsDict(TypedDict):
+        failover_across_pools: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Whether to failover across pools.
+        """
+elif False:
+    LoadBalancerAdaptiveRoutingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LoadBalancerAdaptiveRoutingArgs:
+    def __init__(__self__, *,
+                 failover_across_pools: Optional[pulumi.Input[_builtins.bool]] = None):
+        """
+        :param pulumi.Input[_builtins.bool] failover_across_pools: Whether to failover across pools.
+        """
+        if failover_across_pools is not None:
+            pulumi.set(__self__, "failover_across_pools", failover_across_pools)
+
+    @_builtins.property
+    @pulumi.getter(name="failoverAcrossPools")
+    def failover_across_pools(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Whether to failover across pools.
+        """
+        return pulumi.get(self, "failover_across_pools")
+
+    @failover_across_pools.setter
+    def failover_across_pools(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "failover_across_pools", value)
+
+
+if not MYPY:
+    class LoadBalancerMonitorArgsDict(TypedDict):
+        consecutive_down: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of consecutive failed health checks before the backend is considered down, for example, 5.
+        """
+        consecutive_up: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The number of consecutive successful probes required to consider the target as up, e.g., 3.
+        """
+        expected_codes: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Expected status code, such as 200,202, successful HTTP response.
+        """
+        follow_redirects: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Whether to follow the redirect.
+        """
+        header: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The HTTP headers to be included in the health check request.
+        """
+        interval: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The monitoring interval, such as 60 seconds, checks the frequency.
+        """
+        method: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Monitor request methods, such as GET, methods in the HTTP protocol.
+        """
+        monitoring_region: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Probe Point Region, default to Global
+        - `Global`: Global.
+        - `ChineseMainland`: Chinese mainland.
+        - `OutsideChineseMainland`: Global (excluding the Chinese mainland).
+        """
+        path: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The monitor checks the path, such as/healthcheck, the HTTP request path.
+        """
+        port: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The target port.
+        """
+        timeout: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The timeout for the health check, in seconds. The value range is 1-10.
+        """
+        type: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The type of monitor protocol, such as HTTP, used for health checks. When the value is off, it indicates that no check is performed.
+        """
+elif False:
+    LoadBalancerMonitorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LoadBalancerMonitorArgs:
+    def __init__(__self__, *,
+                 consecutive_down: Optional[pulumi.Input[_builtins.int]] = None,
+                 consecutive_up: Optional[pulumi.Input[_builtins.int]] = None,
+                 expected_codes: Optional[pulumi.Input[_builtins.str]] = None,
+                 follow_redirects: Optional[pulumi.Input[_builtins.bool]] = None,
+                 header: Optional[pulumi.Input[_builtins.str]] = None,
+                 interval: Optional[pulumi.Input[_builtins.int]] = None,
+                 method: Optional[pulumi.Input[_builtins.str]] = None,
+                 monitoring_region: Optional[pulumi.Input[_builtins.str]] = None,
+                 path: Optional[pulumi.Input[_builtins.str]] = None,
+                 port: Optional[pulumi.Input[_builtins.int]] = None,
+                 timeout: Optional[pulumi.Input[_builtins.int]] = None,
+                 type: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.int] consecutive_down: The number of consecutive failed health checks before the backend is considered down, for example, 5.
+        :param pulumi.Input[_builtins.int] consecutive_up: The number of consecutive successful probes required to consider the target as up, e.g., 3.
+        :param pulumi.Input[_builtins.str] expected_codes: Expected status code, such as 200,202, successful HTTP response.
+        :param pulumi.Input[_builtins.bool] follow_redirects: Whether to follow the redirect.
+        :param pulumi.Input[_builtins.str] header: The HTTP headers to be included in the health check request.
+        :param pulumi.Input[_builtins.int] interval: The monitoring interval, such as 60 seconds, checks the frequency.
+        :param pulumi.Input[_builtins.str] method: Monitor request methods, such as GET, methods in the HTTP protocol.
+        :param pulumi.Input[_builtins.str] monitoring_region: Probe Point Region, default to Global
+               - `Global`: Global.
+               - `ChineseMainland`: Chinese mainland.
+               - `OutsideChineseMainland`: Global (excluding the Chinese mainland).
+        :param pulumi.Input[_builtins.str] path: The monitor checks the path, such as/healthcheck, the HTTP request path.
+        :param pulumi.Input[_builtins.int] port: The target port.
+        :param pulumi.Input[_builtins.int] timeout: The timeout for the health check, in seconds. The value range is 1-10.
+        :param pulumi.Input[_builtins.str] type: The type of monitor protocol, such as HTTP, used for health checks. When the value is off, it indicates that no check is performed.
+        """
+        if consecutive_down is not None:
+            pulumi.set(__self__, "consecutive_down", consecutive_down)
+        if consecutive_up is not None:
+            pulumi.set(__self__, "consecutive_up", consecutive_up)
+        if expected_codes is not None:
+            pulumi.set(__self__, "expected_codes", expected_codes)
+        if follow_redirects is not None:
+            pulumi.set(__self__, "follow_redirects", follow_redirects)
+        if header is not None:
+            pulumi.set(__self__, "header", header)
+        if interval is not None:
+            pulumi.set(__self__, "interval", interval)
+        if method is not None:
+            pulumi.set(__self__, "method", method)
+        if monitoring_region is not None:
+            pulumi.set(__self__, "monitoring_region", monitoring_region)
+        if path is not None:
+            pulumi.set(__self__, "path", path)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @_builtins.property
+    @pulumi.getter(name="consecutiveDown")
+    def consecutive_down(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of consecutive failed health checks before the backend is considered down, for example, 5.
+        """
+        return pulumi.get(self, "consecutive_down")
+
+    @consecutive_down.setter
+    def consecutive_down(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "consecutive_down", value)
+
+    @_builtins.property
+    @pulumi.getter(name="consecutiveUp")
+    def consecutive_up(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The number of consecutive successful probes required to consider the target as up, e.g., 3.
+        """
+        return pulumi.get(self, "consecutive_up")
+
+    @consecutive_up.setter
+    def consecutive_up(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "consecutive_up", value)
+
+    @_builtins.property
+    @pulumi.getter(name="expectedCodes")
+    def expected_codes(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Expected status code, such as 200,202, successful HTTP response.
+        """
+        return pulumi.get(self, "expected_codes")
+
+    @expected_codes.setter
+    def expected_codes(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "expected_codes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="followRedirects")
+    def follow_redirects(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Whether to follow the redirect.
+        """
+        return pulumi.get(self, "follow_redirects")
+
+    @follow_redirects.setter
+    def follow_redirects(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "follow_redirects", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def header(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The HTTP headers to be included in the health check request.
+        """
+        return pulumi.get(self, "header")
+
+    @header.setter
+    def header(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "header", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def interval(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The monitoring interval, such as 60 seconds, checks the frequency.
+        """
+        return pulumi.get(self, "interval")
+
+    @interval.setter
+    def interval(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "interval", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def method(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Monitor request methods, such as GET, methods in the HTTP protocol.
+        """
+        return pulumi.get(self, "method")
+
+    @method.setter
+    def method(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "method", value)
+
+    @_builtins.property
+    @pulumi.getter(name="monitoringRegion")
+    def monitoring_region(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Probe Point Region, default to Global
+        - `Global`: Global.
+        - `ChineseMainland`: Chinese mainland.
+        - `OutsideChineseMainland`: Global (excluding the Chinese mainland).
+        """
+        return pulumi.get(self, "monitoring_region")
+
+    @monitoring_region.setter
+    def monitoring_region(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "monitoring_region", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def path(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The monitor checks the path, such as/healthcheck, the HTTP request path.
+        """
+        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
+    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The target port.
+        """
+        return pulumi.get(self, "port")
+
+    @port.setter
+    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "port", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The timeout for the health check, in seconds. The value range is 1-10.
+        """
+        return pulumi.get(self, "timeout")
+
+    @timeout.setter
+    def timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "timeout", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The type of monitor protocol, such as HTTP, used for health checks. When the value is off, it indicates that no check is performed.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "type", value)
+
+
+if not MYPY:
+    class LoadBalancerRandomSteeringArgsDict(TypedDict):
+        default_weight: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The default round-robin weight, used for all pools that do not have individually specified weights. The value range is 0-100.
+        """
+        pool_weights: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
+        """
+        Weight configuration for each backend server pool, where the key is the pool ID and the value is the weight coefficient. The weight coefficient represents the proportion of relative traffic distribution.
+        """
+elif False:
+    LoadBalancerRandomSteeringArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LoadBalancerRandomSteeringArgs:
+    def __init__(__self__, *,
+                 default_weight: Optional[pulumi.Input[_builtins.int]] = None,
+                 pool_weights: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[_builtins.int] default_weight: The default round-robin weight, used for all pools that do not have individually specified weights. The value range is 0-100.
+        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] pool_weights: Weight configuration for each backend server pool, where the key is the pool ID and the value is the weight coefficient. The weight coefficient represents the proportion of relative traffic distribution.
+        """
+        if default_weight is not None:
+            pulumi.set(__self__, "default_weight", default_weight)
+        if pool_weights is not None:
+            pulumi.set(__self__, "pool_weights", pool_weights)
+
+    @_builtins.property
+    @pulumi.getter(name="defaultWeight")
+    def default_weight(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The default round-robin weight, used for all pools that do not have individually specified weights. The value range is 0-100.
+        """
+        return pulumi.get(self, "default_weight")
+
+    @default_weight.setter
+    def default_weight(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "default_weight", value)
+
+    @_builtins.property
+    @pulumi.getter(name="poolWeights")
+    def pool_weights(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
+        """
+        Weight configuration for each backend server pool, where the key is the pool ID and the value is the weight coefficient. The weight coefficient represents the proportion of relative traffic distribution.
+        """
+        return pulumi.get(self, "pool_weights")
+
+    @pool_weights.setter
+    def pool_weights(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "pool_weights", value)
+
+
+if not MYPY:
+    class LoadBalancerRuleArgsDict(TypedDict):
+        fixed_response: NotRequired[pulumi.Input['LoadBalancerRuleFixedResponseArgsDict']]
+        """
+        Executes a specified response after matching the rule. See `fixed_response` below.
+        """
+        overrides: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Modifies the load balancer configuration for the corresponding request after matching the rule. The fields in this configuration will override the corresponding fields in the load balancer configuration.
+        """
+        rule: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Rule content, using conditional expressions to match user requests. When adding global configuration, this parameter does not need to be set. There are two usage scenarios:
+        - Match all incoming requests: value set to true
+        - Match specified request: Set the value to a custom expression, for example: (http.host eq \\"video.example.com\\")
+        """
+        rule_enable: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Rule switch. When adding global configuration, this parameter does not need to be set. Value range:
+        - on: open.
+        - off: close.
+        """
+        rule_name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Rule name. When adding global configuration, this parameter does not need to be set.
+        """
+        sequence: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Order of rule execution. The smaller the value, the higher the priority for execution.
+        """
+        terminates: NotRequired[pulumi.Input[_builtins.bool]]
+        """
+        Whether to terminate the execution of subsequent rules.
+        """
+elif False:
+    LoadBalancerRuleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LoadBalancerRuleArgs:
+    def __init__(__self__, *,
+                 fixed_response: Optional[pulumi.Input['LoadBalancerRuleFixedResponseArgs']] = None,
+                 overrides: Optional[pulumi.Input[_builtins.str]] = None,
+                 rule: Optional[pulumi.Input[_builtins.str]] = None,
+                 rule_enable: Optional[pulumi.Input[_builtins.str]] = None,
+                 rule_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 sequence: Optional[pulumi.Input[_builtins.int]] = None,
+                 terminates: Optional[pulumi.Input[_builtins.bool]] = None):
+        """
+        :param pulumi.Input['LoadBalancerRuleFixedResponseArgs'] fixed_response: Executes a specified response after matching the rule. See `fixed_response` below.
+        :param pulumi.Input[_builtins.str] overrides: Modifies the load balancer configuration for the corresponding request after matching the rule. The fields in this configuration will override the corresponding fields in the load balancer configuration.
+        :param pulumi.Input[_builtins.str] rule: Rule content, using conditional expressions to match user requests. When adding global configuration, this parameter does not need to be set. There are two usage scenarios:
+               - Match all incoming requests: value set to true
+               - Match specified request: Set the value to a custom expression, for example: (http.host eq \\"video.example.com\\")
+        :param pulumi.Input[_builtins.str] rule_enable: Rule switch. When adding global configuration, this parameter does not need to be set. Value range:
+               - on: open.
+               - off: close.
+        :param pulumi.Input[_builtins.str] rule_name: Rule name. When adding global configuration, this parameter does not need to be set.
+        :param pulumi.Input[_builtins.int] sequence: Order of rule execution. The smaller the value, the higher the priority for execution.
+        :param pulumi.Input[_builtins.bool] terminates: Whether to terminate the execution of subsequent rules.
+        """
+        if fixed_response is not None:
+            pulumi.set(__self__, "fixed_response", fixed_response)
+        if overrides is not None:
+            pulumi.set(__self__, "overrides", overrides)
+        if rule is not None:
+            pulumi.set(__self__, "rule", rule)
+        if rule_enable is not None:
+            pulumi.set(__self__, "rule_enable", rule_enable)
+        if rule_name is not None:
+            pulumi.set(__self__, "rule_name", rule_name)
+        if sequence is not None:
+            pulumi.set(__self__, "sequence", sequence)
+        if terminates is not None:
+            pulumi.set(__self__, "terminates", terminates)
+
+    @_builtins.property
+    @pulumi.getter(name="fixedResponse")
+    def fixed_response(self) -> Optional[pulumi.Input['LoadBalancerRuleFixedResponseArgs']]:
+        """
+        Executes a specified response after matching the rule. See `fixed_response` below.
+        """
+        return pulumi.get(self, "fixed_response")
+
+    @fixed_response.setter
+    def fixed_response(self, value: Optional[pulumi.Input['LoadBalancerRuleFixedResponseArgs']]):
+        pulumi.set(self, "fixed_response", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def overrides(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Modifies the load balancer configuration for the corresponding request after matching the rule. The fields in this configuration will override the corresponding fields in the load balancer configuration.
+        """
+        return pulumi.get(self, "overrides")
+
+    @overrides.setter
+    def overrides(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "overrides", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def rule(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Rule content, using conditional expressions to match user requests. When adding global configuration, this parameter does not need to be set. There are two usage scenarios:
+        - Match all incoming requests: value set to true
+        - Match specified request: Set the value to a custom expression, for example: (http.host eq \\"video.example.com\\")
+        """
+        return pulumi.get(self, "rule")
+
+    @rule.setter
+    def rule(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rule", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ruleEnable")
+    def rule_enable(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Rule switch. When adding global configuration, this parameter does not need to be set. Value range:
+        - on: open.
+        - off: close.
+        """
+        return pulumi.get(self, "rule_enable")
+
+    @rule_enable.setter
+    def rule_enable(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rule_enable", value)
+
+    @_builtins.property
+    @pulumi.getter(name="ruleName")
+    def rule_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Rule name. When adding global configuration, this parameter does not need to be set.
+        """
+        return pulumi.get(self, "rule_name")
+
+    @rule_name.setter
+    def rule_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "rule_name", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def sequence(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Order of rule execution. The smaller the value, the higher the priority for execution.
+        """
+        return pulumi.get(self, "sequence")
+
+    @sequence.setter
+    def sequence(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "sequence", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def terminates(self) -> Optional[pulumi.Input[_builtins.bool]]:
+        """
+        Whether to terminate the execution of subsequent rules.
+        """
+        return pulumi.get(self, "terminates")
+
+    @terminates.setter
+    def terminates(self, value: Optional[pulumi.Input[_builtins.bool]]):
+        pulumi.set(self, "terminates", value)
+
+
+if not MYPY:
+    class LoadBalancerRuleFixedResponseArgsDict(TypedDict):
+        content_type: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The Content-Type field in the HTTP Header.
+        """
+        location: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The location field in the http return.
+        """
+        message_body: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The body value of the response.
+        """
+        status_code: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Status Code.
+        """
+elif False:
+    LoadBalancerRuleFixedResponseArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class LoadBalancerRuleFixedResponseArgs:
+    def __init__(__self__, *,
+                 content_type: Optional[pulumi.Input[_builtins.str]] = None,
+                 location: Optional[pulumi.Input[_builtins.str]] = None,
+                 message_body: Optional[pulumi.Input[_builtins.str]] = None,
+                 status_code: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.str] content_type: The Content-Type field in the HTTP Header.
+        :param pulumi.Input[_builtins.str] location: The location field in the http return.
+        :param pulumi.Input[_builtins.str] message_body: The body value of the response.
+        :param pulumi.Input[_builtins.int] status_code: Status Code.
+        """
+        if content_type is not None:
+            pulumi.set(__self__, "content_type", content_type)
+        if location is not None:
+            pulumi.set(__self__, "location", location)
+        if message_body is not None:
+            pulumi.set(__self__, "message_body", message_body)
+        if status_code is not None:
+            pulumi.set(__self__, "status_code", status_code)
+
+    @_builtins.property
+    @pulumi.getter(name="contentType")
+    def content_type(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The Content-Type field in the HTTP Header.
+        """
+        return pulumi.get(self, "content_type")
+
+    @content_type.setter
+    def content_type(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "content_type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def location(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The location field in the http return.
+        """
+        return pulumi.get(self, "location")
+
+    @location.setter
+    def location(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "location", value)
+
+    @_builtins.property
+    @pulumi.getter(name="messageBody")
+    def message_body(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The body value of the response.
+        """
+        return pulumi.get(self, "message_body")
+
+    @message_body.setter
+    def message_body(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "message_body", value)
+
+    @_builtins.property
+    @pulumi.getter(name="statusCode")
+    def status_code(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Status Code.
+        """
+        return pulumi.get(self, "status_code")
+
+    @status_code.setter
+    def status_code(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "status_code", value)
+
+
 if not MYPY:
     class OriginPoolOriginArgsDict(TypedDict):
         address: NotRequired[pulumi.Input[_builtins.str]]