pulumiverse-scaleway 1.27.0a1744869119__py3-none-any.whl → 1.39.0a1764841480__py3-none-any.whl

pulumiverse_scaleway/loadbalancers/outputs.py

@@ -1,8 +1,8 @@
 # coding=utf-8
-# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -28,6 +28,7 @@ __all__ = [
     'FrontendAclAction',
     'FrontendAclActionRedirect',
     'FrontendAclMatch',
+    'LoadBalancerPrivateIp',
     'LoadBalancerPrivateNetwork',
     'GetAclsAclResult',
     'GetAclsAclActionResult',
@@ -46,6 +47,7 @@ __all__ = [
     'GetFrontendAclMatchResult',
     'GetFrontendsFrontendResult',
     'GetIpsIpResult',
+    'GetLoadBalancerPrivateIpResult',
     'GetLoadBalancerPrivateNetworkResult',
     'GetLoadBalancersLbResult',
     'GetLoadBalancersLbInstanceResult',
@@ -56,25 +58,25 @@ __all__ = [
 @pulumi.output_type
 class AclAction(dict):
     def __init__(__self__, *,
-                 type: str,
+                 type: _builtins.str,
                  redirects: Optional[Sequence['outputs.AclActionRedirect']] = None):
         """
-        :param str type: The action type. Possible values are: `allow` or `deny` or `redirect`.
+        :param _builtins.str type: The action type. Possible values are: `allow` or `deny` or `redirect`.
         :param Sequence['AclActionRedirectArgs'] redirects: Redirect parameters when using an ACL with `redirect` action.
         """
         pulumi.set(__self__, "type", type)
         if redirects is not None:
             pulumi.set(__self__, "redirects", redirects)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The action type. Possible values are: `allow` or `deny` or `redirect`.
         """
         return pulumi.get(self, "type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def redirects(self) -> Optional[Sequence['outputs.AclActionRedirect']]:
         """
@@ -86,13 +88,13 @@ class AclAction(dict):
 @pulumi.output_type
 class AclActionRedirect(dict):
     def __init__(__self__, *,
-                 code: Optional[int] = None,
-                 target: Optional[str] = None,
-                 type: Optional[str] = None):
+                 code: Optional[_builtins.int] = None,
+                 target: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
         """
-        :param int code: The HTTP redirect code to use. Valid values are `301`, `302`, `303`, `307` and `308`.
-        :param str target: An URL can be used in case of a location redirect (e.g. `https://scaleway.com` will redirect to this same URL). A scheme name (e.g. `https`, `http`, `ftp`, `git`) will replace the request's original scheme.
-        :param str type: The redirect type. Possible values are: `location` or `scheme`.
+        :param _builtins.int code: The HTTP redirect code to use. Valid values are `301`, `302`, `303`, `307` and `308`.
+        :param _builtins.str target: An URL can be used in case of a location redirect (e.g. `https://scaleway.com` will redirect to this same URL). A scheme name (e.g. `https`, `http`, `ftp`, `git`) will replace the request's original scheme.
+        :param _builtins.str type: The redirect type. Possible values are: `location` or `scheme`.
         """
         if code is not None:
             pulumi.set(__self__, "code", code)
@@ -101,25 +103,25 @@ class AclActionRedirect(dict):
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> Optional[int]:
+    def code(self) -> Optional[_builtins.int]:
         """
         The HTTP redirect code to use. Valid values are `301`, `302`, `303`, `307` and `308`.
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> Optional[str]:
+    def target(self) -> Optional[_builtins.str]:
         """
         An URL can be used in case of a location redirect (e.g. `https://scaleway.com` will redirect to this same URL). A scheme name (e.g. `https`, `http`, `ftp`, `git`) will replace the request's original scheme.
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         The redirect type. Possible values are: `location` or `scheme`.
         """
@@ -139,6 +141,8 @@ class AclMatch(dict):
             suggest = "http_filter_values"
         elif key == "ipSubnets":
             suggest = "ip_subnets"
+        elif key == "ipsEdgeServices":
+            suggest = "ips_edge_services"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in AclMatch. Access the value via the '{suggest}' property getter instead.")
@@ -152,20 +156,22 @@ class AclMatch(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 http_filter: Optional[str] = None,
-                 http_filter_option: Optional[str] = None,
-                 http_filter_values: Optional[Sequence[str]] = None,
-                 invert: Optional[bool] = None,
-                 ip_subnets: Optional[Sequence[str]] = None):
-        """
-        :param str http_filter: The HTTP filter to match. This filter is supported only if your backend protocol has an HTTP forward protocol.
+                 http_filter: Optional[_builtins.str] = None,
+                 http_filter_option: Optional[_builtins.str] = None,
+                 http_filter_values: Optional[Sequence[_builtins.str]] = None,
+                 invert: Optional[_builtins.bool] = None,
+                 ip_subnets: Optional[Sequence[_builtins.str]] = None,
+                 ips_edge_services: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str http_filter: The HTTP filter to match. This filter is supported only if your backend protocol has an HTTP forward protocol.
                It extracts the request's URL path, which starts at the first slash and ends before the question mark (without the host part).
                Possible values are: `acl_http_filter_none`, `path_begin`, `path_end`, `http_header_match` or `regex`.
-        :param str http_filter_option: If you have `http_filter` at `http_header_match`, you can use this field to filter on the HTTP header's value.
-        :param Sequence[str] http_filter_values: A list of possible values to match for the given HTTP filter.
+        :param _builtins.str http_filter_option: If you have `http_filter` at `http_header_match`, you can use this field to filter on the HTTP header's value.
+        :param Sequence[_builtins.str] http_filter_values: A list of possible values to match for the given HTTP filter.
                Keep in mind that in the case of `http_header_match` the HTTP header field name is case insensitive.
-        :param bool invert: If set to `true`, the condition will be of type "unless".
-        :param Sequence[str] ip_subnets: A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
+        :param _builtins.bool invert: If set to `true`, the condition will be of type "unless".
+        :param Sequence[_builtins.str] ip_subnets: A list of IPs, or CIDR v4/v6 addresses of the session client, to match. Only one of `ip_subnet` and `ips_edge_services` should be specified.
+        :param _builtins.bool ips_edge_services: Defines whether Edge Services IPs should be matched. Only one of `ip_subnet` and `ips_edge_services` should be specified.
         """
         if http_filter is not None:
             pulumi.set(__self__, "http_filter", http_filter)
@@ -177,10 +183,12 @@ class AclMatch(dict):
             pulumi.set(__self__, "invert", invert)
         if ip_subnets is not None:
             pulumi.set(__self__, "ip_subnets", ip_subnets)
+        if ips_edge_services is not None:
+            pulumi.set(__self__, "ips_edge_services", ips_edge_services)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilter")
-    def http_filter(self) -> Optional[str]:
+    def http_filter(self) -> Optional[_builtins.str]:
         """
         The HTTP filter to match. This filter is supported only if your backend protocol has an HTTP forward protocol.
         It extracts the request's URL path, which starts at the first slash and ends before the question mark (without the host part).
@@ -188,39 +196,47 @@ class AclMatch(dict):
         """
         return pulumi.get(self, "http_filter")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterOption")
-    def http_filter_option(self) -> Optional[str]:
+    def http_filter_option(self) -> Optional[_builtins.str]:
         """
         If you have `http_filter` at `http_header_match`, you can use this field to filter on the HTTP header's value.
         """
         return pulumi.get(self, "http_filter_option")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterValues")
-    def http_filter_values(self) -> Optional[Sequence[str]]:
+    def http_filter_values(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of possible values to match for the given HTTP filter.
         Keep in mind that in the case of `http_header_match` the HTTP header field name is case insensitive.
         """
         return pulumi.get(self, "http_filter_values")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def invert(self) -> Optional[bool]:
+    def invert(self) -> Optional[_builtins.bool]:
         """
         If set to `true`, the condition will be of type "unless".
         """
         return pulumi.get(self, "invert")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipSubnets")
-    def ip_subnets(self) -> Optional[Sequence[str]]:
+    def ip_subnets(self) -> Optional[Sequence[_builtins.str]]:
         """
-        A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
+        A list of IPs, or CIDR v4/v6 addresses of the session client, to match. Only one of `ip_subnet` and `ips_edge_services` should be specified.
         """
         return pulumi.get(self, "ip_subnets")
 
+    @_builtins.property
+    @pulumi.getter(name="ipsEdgeServices")
+    def ips_edge_services(self) -> Optional[_builtins.bool]:
+        """
+        Defines whether Edge Services IPs should be matched. Only one of `ip_subnet` and `ips_edge_services` should be specified.
+        """
+        return pulumi.get(self, "ips_edge_services")
+
 
 @pulumi.output_type
 class BackendHealthCheckHttp(dict):
@@ -242,15 +258,15 @@ class BackendHealthCheckHttp(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 uri: str,
-                 code: Optional[int] = None,
-                 host_header: Optional[str] = None,
-                 method: Optional[str] = None):
+                 uri: _builtins.str,
+                 code: Optional[_builtins.int] = None,
+                 host_header: Optional[_builtins.str] = None,
+                 method: Optional[_builtins.str] = None):
         """
-        :param str uri: The HTTP endpoint URL to call for HC requests
-        :param int code: The expected HTTP status code
-        :param str host_header: The HTTP host header to use for HC requests
-        :param str method: The HTTP method to use for HC requests
+        :param _builtins.str uri: The HTTP endpoint URL to call for HC requests
+        :param _builtins.int code: The expected HTTP status code
+        :param _builtins.str host_header: The HTTP host header to use for HC requests
+        :param _builtins.str method: The HTTP method to use for HC requests
         """
         pulumi.set(__self__, "uri", uri)
         if code is not None:
@@ -260,33 +276,33 @@ class BackendHealthCheckHttp(dict):
         if method is not None:
             pulumi.set(__self__, "method", method)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> str:
+    def uri(self) -> _builtins.str:
         """
         The HTTP endpoint URL to call for HC requests
         """
         return pulumi.get(self, "uri")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> Optional[int]:
+    def code(self) -> Optional[_builtins.int]:
         """
         The expected HTTP status code
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostHeader")
-    def host_header(self) -> Optional[str]:
+    def host_header(self) -> Optional[_builtins.str]:
         """
         The HTTP host header to use for HC requests
         """
         return pulumi.get(self, "host_header")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def method(self) -> Optional[str]:
+    def method(self) -> Optional[_builtins.str]:
         """
         The HTTP method to use for HC requests
         """
@@ -313,17 +329,17 @@ class BackendHealthCheckHttps(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 uri: str,
-                 code: Optional[int] = None,
-                 host_header: Optional[str] = None,
-                 method: Optional[str] = None,
-                 sni: Optional[str] = None):
-        """
-        :param str uri: The HTTPS endpoint URL to call for HC requests
-        :param int code: The expected HTTP status code
-        :param str host_header: The HTTP host header to use for HC requests
-        :param str method: The HTTP method to use for HC requests
-        :param str sni: The SNI to use for HC requests over SSL
+                 uri: _builtins.str,
+                 code: Optional[_builtins.int] = None,
+                 host_header: Optional[_builtins.str] = None,
+                 method: Optional[_builtins.str] = None,
+                 sni: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str uri: The HTTPS endpoint URL to call for HC requests
+        :param _builtins.int code: The expected HTTP status code
+        :param _builtins.str host_header: The HTTP host header to use for HC requests
+        :param _builtins.str method: The HTTP method to use for HC requests
+        :param _builtins.str sni: The SNI to use for HC requests over SSL
         """
         pulumi.set(__self__, "uri", uri)
         if code is not None:
@@ -335,41 +351,41 @@ class BackendHealthCheckHttps(dict):
         if sni is not None:
             pulumi.set(__self__, "sni", sni)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> str:
+    def uri(self) -> _builtins.str:
         """
         The HTTPS endpoint URL to call for HC requests
         """
         return pulumi.get(self, "uri")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> Optional[int]:
+    def code(self) -> Optional[_builtins.int]:
         """
         The expected HTTP status code
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostHeader")
-    def host_header(self) -> Optional[str]:
+    def host_header(self) -> Optional[_builtins.str]:
         """
         The HTTP host header to use for HC requests
         """
         return pulumi.get(self, "host_header")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def method(self) -> Optional[str]:
+    def method(self) -> Optional[_builtins.str]:
         """
         The HTTP method to use for HC requests
         """
         return pulumi.get(self, "method")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def sni(self) -> Optional[str]:
+    def sni(self) -> Optional[_builtins.str]:
         """
         The SNI to use for HC requests over SSL
         """
@@ -402,15 +418,15 @@ class CertificateCustomCertificate(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 certificate_chain: str):
+                 certificate_chain: _builtins.str):
         """
-        :param str certificate_chain: The full PEM-formatted certificate chain
+        :param _builtins.str certificate_chain: The full PEM-formatted certificate chain
         """
         pulumi.set(__self__, "certificate_chain", certificate_chain)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="certificateChain")
-    def certificate_chain(self) -> str:
+    def certificate_chain(self) -> _builtins.str:
         """
         The full PEM-formatted certificate chain
         """
@@ -439,27 +455,27 @@ class CertificateLetsencrypt(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 common_name: str,
-                 subject_alternative_names: Optional[Sequence[str]] = None):
+                 common_name: _builtins.str,
+                 subject_alternative_names: Optional[Sequence[_builtins.str]] = None):
         """
-        :param str common_name: Main domain of the certificate
-        :param Sequence[str] subject_alternative_names: The alternative domain names of the certificate
+        :param _builtins.str common_name: Main domain of the certificate
+        :param Sequence[_builtins.str] subject_alternative_names: The alternative domain names of the certificate
         """
         pulumi.set(__self__, "common_name", common_name)
         if subject_alternative_names is not None:
             pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="commonName")
-    def common_name(self) -> str:
+    def common_name(self) -> _builtins.str:
         """
         Main domain of the certificate
         """
         return pulumi.get(self, "common_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="subjectAlternativeNames")
-    def subject_alternative_names(self) -> Optional[Sequence[str]]:
+    def subject_alternative_names(self) -> Optional[Sequence[_builtins.str]]:
         """
         The alternative domain names of the certificate
         """
@@ -490,17 +506,17 @@ class FrontendAcl(dict):
     def __init__(__self__, *,
                  action: 'outputs.FrontendAclAction',
                  match: 'outputs.FrontendAclMatch',
-                 created_at: Optional[str] = None,
-                 description: Optional[str] = None,
-                 name: Optional[str] = None,
-                 updated_at: Optional[str] = None):
+                 created_at: Optional[_builtins.str] = None,
+                 description: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None,
+                 updated_at: Optional[_builtins.str] = None):
         """
         :param 'FrontendAclActionArgs' action: Action to undertake when an ACL filter matches.
-        :param 'FrontendAclMatchArgs' match: The ACL match rule. At least `ip_subnet` or `http_filter` and `http_filter_value` are required.
-        :param str created_at: IsDate and time of ACL's creation (RFC 3339 format)
-        :param str description: Description of the ACL
-        :param str name: The ACL name. If not provided it will be randomly generated.
-        :param str updated_at: IsDate and time of ACL's update (RFC 3339 format)
+        :param 'FrontendAclMatchArgs' match: The ACL match rule. At least `ip_subnet` or `ips_edge_services` or `http_filter` and `http_filter_value` are required.
+        :param _builtins.str created_at: The date and time the frontend was created.
+        :param _builtins.str description: Description of the ACL
+        :param _builtins.str name: The ACL name. If not provided it will be randomly generated.
+        :param _builtins.str updated_at: The date and time the frontend resource was updated.
         """
         pulumi.set(__self__, "action", action)
         pulumi.set(__self__, "match", match)
@@ -513,7 +529,7 @@ class FrontendAcl(dict):
         if updated_at is not None:
             pulumi.set(__self__, "updated_at", updated_at)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def action(self) -> 'outputs.FrontendAclAction':
         """
@@ -521,43 +537,43 @@ class FrontendAcl(dict):
         """
         return pulumi.get(self, "action")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def match(self) -> 'outputs.FrontendAclMatch':
         """
-        The ACL match rule. At least `ip_subnet` or `http_filter` and `http_filter_value` are required.
+        The ACL match rule. At least `ip_subnet` or `ips_edge_services` or `http_filter` and `http_filter_value` are required.
         """
         return pulumi.get(self, "match")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> Optional[str]:
+    def created_at(self) -> Optional[_builtins.str]:
         """
-        IsDate and time of ACL's creation (RFC 3339 format)
+        The date and time the frontend was created.
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> Optional[str]:
+    def description(self) -> Optional[_builtins.str]:
         """
         Description of the ACL
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[str]:
+    def name(self) -> Optional[_builtins.str]:
         """
         The ACL name. If not provided it will be randomly generated.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updatedAt")
-    def updated_at(self) -> Optional[str]:
+    def updated_at(self) -> Optional[_builtins.str]:
         """
-        IsDate and time of ACL's update (RFC 3339 format)
+        The date and time the frontend resource was updated.
         """
         return pulumi.get(self, "updated_at")
 
@@ -565,25 +581,25 @@ class FrontendAcl(dict):
 @pulumi.output_type
 class FrontendAclAction(dict):
     def __init__(__self__, *,
-                 type: str,
+                 type: _builtins.str,
                  redirects: Optional[Sequence['outputs.FrontendAclActionRedirect']] = None):
         """
-        :param str type: The action type. Possible values are: `allow` or `deny` or `redirect`.
+        :param _builtins.str type: The action type. Possible values are: `allow` or `deny` or `redirect`.
         :param Sequence['FrontendAclActionRedirectArgs'] redirects: Redirect parameters when using an ACL with `redirect` action.
         """
         pulumi.set(__self__, "type", type)
         if redirects is not None:
             pulumi.set(__self__, "redirects", redirects)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The action type. Possible values are: `allow` or `deny` or `redirect`.
         """
         return pulumi.get(self, "type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def redirects(self) -> Optional[Sequence['outputs.FrontendAclActionRedirect']]:
         """
@@ -595,13 +611,13 @@ class FrontendAclAction(dict):
 @pulumi.output_type
 class FrontendAclActionRedirect(dict):
     def __init__(__self__, *,
-                 code: Optional[int] = None,
-                 target: Optional[str] = None,
-                 type: Optional[str] = None):
+                 code: Optional[_builtins.int] = None,
+                 target: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
         """
-        :param int code: The HTTP redirect code to use. Valid values are `301`, `302`, `303`, `307` and `308`.
-        :param str target: A URL can be used in case of a location redirect (e.g. `https://scaleway.com` will redirect to this same URL). A scheme name (e.g. `https`, `http`, `ftp`, `git`) will replace the request's original scheme.
-        :param str type: The redirect type. Possible values are: `location` or `scheme`.
+        :param _builtins.int code: The HTTP redirect code to use. Valid values are `301`, `302`, `303`, `307` and `308`.
+        :param _builtins.str target: A URL can be used in case of a location redirect (e.g. `https://scaleway.com` will redirect to this same URL). A scheme name (e.g. `https`, `http`, `ftp`, `git`) will replace the request's original scheme.
+        :param _builtins.str type: The redirect type. Possible values are: `location` or `scheme`.
         """
         if code is not None:
             pulumi.set(__self__, "code", code)
@@ -610,25 +626,25 @@ class FrontendAclActionRedirect(dict):
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> Optional[int]:
+    def code(self) -> Optional[_builtins.int]:
         """
         The HTTP redirect code to use. Valid values are `301`, `302`, `303`, `307` and `308`.
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> Optional[str]:
+    def target(self) -> Optional[_builtins.str]:
         """
         A URL can be used in case of a location redirect (e.g. `https://scaleway.com` will redirect to this same URL). A scheme name (e.g. `https`, `http`, `ftp`, `git`) will replace the request's original scheme.
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         The redirect type. Possible values are: `location` or `scheme`.
         """
@@ -648,6 +664,8 @@ class FrontendAclMatch(dict):
             suggest = "http_filter_values"
         elif key == "ipSubnets":
             suggest = "ip_subnets"
+        elif key == "ipsEdgeServices":
+            suggest = "ips_edge_services"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in FrontendAclMatch. Access the value via the '{suggest}' property getter instead.")
@@ -661,20 +679,22 @@ class FrontendAclMatch(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 http_filter: Optional[str] = None,
-                 http_filter_option: Optional[str] = None,
-                 http_filter_values: Optional[Sequence[str]] = None,
-                 invert: Optional[bool] = None,
-                 ip_subnets: Optional[Sequence[str]] = None):
-        """
-        :param str http_filter: The HTTP filter to match. This filter is supported only if your backend protocol has an HTTP forward protocol.
+                 http_filter: Optional[_builtins.str] = None,
+                 http_filter_option: Optional[_builtins.str] = None,
+                 http_filter_values: Optional[Sequence[_builtins.str]] = None,
+                 invert: Optional[_builtins.bool] = None,
+                 ip_subnets: Optional[Sequence[_builtins.str]] = None,
+                 ips_edge_services: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str http_filter: The HTTP filter to match. This filter is supported only if your backend protocol has an HTTP forward protocol.
                It extracts the request's URL path, which starts at the first slash and ends before the question mark (without the host part).
                Possible values are: `acl_http_filter_none`, `path_begin`, `path_end`, `http_header_match` or `regex`.
-        :param str http_filter_option: If you have `http_filter` at `http_header_match`, you can use this field to filter on the HTTP header's value.
-        :param Sequence[str] http_filter_values: A list of possible values to match for the given HTTP filter.
+        :param _builtins.str http_filter_option: If you have `http_filter` at `http_header_match`, you can use this field to filter on the HTTP header's value.
+        :param Sequence[_builtins.str] http_filter_values: A list of possible values to match for the given HTTP filter.
                Keep in mind that in the case of `http_header_match` the HTTP header field name is case insensitive.
-        :param bool invert: If set to `true`, the condition will be of type "unless".
-        :param Sequence[str] ip_subnets: A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
+        :param _builtins.bool invert: If set to `true`, the condition will be of type "unless".
+        :param Sequence[_builtins.str] ip_subnets: A list of IPs, or CIDR v4/v6 addresses of the session client, to match. Only one of `ip_subnet` and `ips_edge_services` should be specified.
+        :param _builtins.bool ips_edge_services: Defines whether Edge Services IPs should be matched. Only one of `ip_subnet` and `ips_edge_services` should be specified.
         """
         if http_filter is not None:
             pulumi.set(__self__, "http_filter", http_filter)
@@ -686,10 +706,12 @@ class FrontendAclMatch(dict):
             pulumi.set(__self__, "invert", invert)
         if ip_subnets is not None:
             pulumi.set(__self__, "ip_subnets", ip_subnets)
+        if ips_edge_services is not None:
+            pulumi.set(__self__, "ips_edge_services", ips_edge_services)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilter")
-    def http_filter(self) -> Optional[str]:
+    def http_filter(self) -> Optional[_builtins.str]:
         """
         The HTTP filter to match. This filter is supported only if your backend protocol has an HTTP forward protocol.
         It extracts the request's URL path, which starts at the first slash and ends before the question mark (without the host part).
@@ -697,39 +719,78 @@ class FrontendAclMatch(dict):
         """
         return pulumi.get(self, "http_filter")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterOption")
-    def http_filter_option(self) -> Optional[str]:
+    def http_filter_option(self) -> Optional[_builtins.str]:
         """
         If you have `http_filter` at `http_header_match`, you can use this field to filter on the HTTP header's value.
         """
         return pulumi.get(self, "http_filter_option")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterValues")
-    def http_filter_values(self) -> Optional[Sequence[str]]:
+    def http_filter_values(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of possible values to match for the given HTTP filter.
         Keep in mind that in the case of `http_header_match` the HTTP header field name is case insensitive.
         """
         return pulumi.get(self, "http_filter_values")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def invert(self) -> Optional[bool]:
+    def invert(self) -> Optional[_builtins.bool]:
         """
         If set to `true`, the condition will be of type "unless".
         """
         return pulumi.get(self, "invert")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipSubnets")
-    def ip_subnets(self) -> Optional[Sequence[str]]:
+    def ip_subnets(self) -> Optional[Sequence[_builtins.str]]:
         """
-        A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
+        A list of IPs, or CIDR v4/v6 addresses of the session client, to match. Only one of `ip_subnet` and `ips_edge_services` should be specified.
         """
         return pulumi.get(self, "ip_subnets")
 
+    @_builtins.property
+    @pulumi.getter(name="ipsEdgeServices")
+    def ips_edge_services(self) -> Optional[_builtins.bool]:
+        """
+        Defines whether Edge Services IPs should be matched. Only one of `ip_subnet` and `ips_edge_services` should be specified.
+        """
+        return pulumi.get(self, "ips_edge_services")
+
+
+@pulumi.output_type
+class LoadBalancerPrivateIp(dict):
+    def __init__(__self__, *,
+                 address: Optional[_builtins.str] = None,
+                 id: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str address: The private IP address.
+        :param _builtins.str id: The ID of the IP address resource.
+        """
+        if address is not None:
+            pulumi.set(__self__, "address", address)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def address(self) -> Optional[_builtins.str]:
+        """
+        The private IP address.
+        """
+        return pulumi.get(self, "address")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.str]:
+        """
+        The ID of the IP address resource.
+        """
+        return pulumi.get(self, "id")
+
 
 @pulumi.output_type
 class LoadBalancerPrivateNetwork(dict):
@@ -742,8 +803,8 @@ class LoadBalancerPrivateNetwork(dict):
             suggest = "dhcp_config"
         elif key == "ipamIds":
             suggest = "ipam_ids"
-        elif key == "staticConfig":
-            suggest = "static_config"
+        elif key == "staticConfigs":
+            suggest = "static_configs"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in LoadBalancerPrivateNetwork. Access the value via the '{suggest}' property getter instead.")
@@ -757,79 +818,79 @@ class LoadBalancerPrivateNetwork(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 private_network_id: str,
-                 dhcp_config: Optional[bool] = None,
-                 ipam_ids: Optional[str] = None,
-                 static_config: Optional[str] = None,
-                 status: Optional[str] = None,
-                 zone: Optional[str] = None):
-        """
-        :param str private_network_id: The ID of the Private Network to attach to.
+                 private_network_id: _builtins.str,
+                 dhcp_config: Optional[_builtins.bool] = None,
+                 ipam_ids: Optional[_builtins.str] = None,
+                 static_configs: Optional[Sequence[_builtins.str]] = None,
+                 status: Optional[_builtins.str] = None,
+                 zone: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str private_network_id: The ID of the Private Network to attach to.
                - > **Important:** Updates to `private_network` will recreate the attachment.
-        :param bool dhcp_config: Please use `ipam_ids`. Set to `true` if you want to let DHCP assign IP addresses.
-        :param str ipam_ids: IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network.
-        :param str static_config: Please use `ipam_ids`. Define a local ip address of your choice for the load balancer instance.
-        :param str status: The status of the private network connection.
-        :param str zone: `zone`) The zone of the Load Balancer.
+        :param _builtins.bool dhcp_config: Set to true if you want to let DHCP assign IP addresses
+        :param _builtins.str ipam_ids: IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network.
+        :param Sequence[_builtins.str] static_configs: Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
+        :param _builtins.str status: The status of the private network connection.
+        :param _builtins.str zone: `zone`) The zone of the Load Balancer.
         """
         pulumi.set(__self__, "private_network_id", private_network_id)
         if dhcp_config is not None:
             pulumi.set(__self__, "dhcp_config", dhcp_config)
         if ipam_ids is not None:
             pulumi.set(__self__, "ipam_ids", ipam_ids)
-        if static_config is not None:
-            pulumi.set(__self__, "static_config", static_config)
+        if static_configs is not None:
+            pulumi.set(__self__, "static_configs", static_configs)
         if status is not None:
             pulumi.set(__self__, "status", status)
         if zone is not None:
             pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="privateNetworkId")
-    def private_network_id(self) -> str:
+    def private_network_id(self) -> _builtins.str:
         """
         The ID of the Private Network to attach to.
         - > **Important:** Updates to `private_network` will recreate the attachment.
         """
         return pulumi.get(self, "private_network_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="dhcpConfig")
     @_utilities.deprecated("""dhcp_config field is deprecated, please use `private_network_id` or `ipam_ids` instead""")
-    def dhcp_config(self) -> Optional[bool]:
+    def dhcp_config(self) -> Optional[_builtins.bool]:
         """
-        Please use `ipam_ids`. Set to `true` if you want to let DHCP assign IP addresses.
+        Set to true if you want to let DHCP assign IP addresses
         """
         return pulumi.get(self, "dhcp_config")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipamIds")
-    def ipam_ids(self) -> Optional[str]:
+    def ipam_ids(self) -> Optional[_builtins.str]:
         """
         IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network.
         """
         return pulumi.get(self, "ipam_ids")
 
-    @property
-    @pulumi.getter(name="staticConfig")
+    @_builtins.property
+    @pulumi.getter(name="staticConfigs")
     @_utilities.deprecated("""static_config field is deprecated, please use `private_network_id` or `ipam_ids` instead""")
-    def static_config(self) -> Optional[str]:
+    def static_configs(self) -> Optional[Sequence[_builtins.str]]:
         """
-        Please use `ipam_ids`. Define a local ip address of your choice for the load balancer instance.
+        Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
         """
-        return pulumi.get(self, "static_config")
+        return pulumi.get(self, "static_configs")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def status(self) -> Optional[str]:
+    def status(self) -> Optional[_builtins.str]:
         """
         The status of the private network connection.
         """
         return pulumi.get(self, "status")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def zone(self) -> Optional[str]:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone of the Load Balancer.
         """
@@ -840,26 +901,26 @@ class LoadBalancerPrivateNetwork(dict):
 class GetAclsAclResult(dict):
     def __init__(__self__, *,
                  actions: Sequence['outputs.GetAclsAclActionResult'],
-                 created_at: str,
-                 description: str,
-                 frontend_id: str,
-                 id: str,
-                 index: int,
+                 created_at: _builtins.str,
+                 description: _builtins.str,
+                 frontend_id: _builtins.str,
+                 id: _builtins.str,
+                 index: _builtins.int,
                  matches: Sequence['outputs.GetAclsAclMatchResult'],
-                 name: str,
-                 update_at: str):
+                 name: _builtins.str,
+                 update_at: _builtins.str):
         """
         :param Sequence['GetAclsAclActionArgs'] actions: The action to be undertaken when an ACL filter matches.
-        :param str created_at: The date on which the ACL was created (RFC 3339 format).
-        :param str description: The description of the ACL resource.
-        :param str frontend_id: The frontend ID this ACL is attached to. ACLs with a matching frontend ID are listed.
+        :param _builtins.str created_at: The date on which the ACL was created (RFC 3339 format).
+        :param _builtins.str description: The description of the ACL resource.
+        :param _builtins.str frontend_id: The frontend ID this ACL is attached to. ACLs with a matching frontend ID are listed.
                > **Important:** LB frontend IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
-        :param str id: The associated ACL ID.
+        :param _builtins.str id: The associated ACL ID.
                > **Important:** LB ACLs' IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
-        :param int index: The priority of this ACL in the ordered list.
+        :param _builtins.int index: The priority of this ACL in the ordered list.
         :param Sequence['GetAclsAclMatchArgs'] matches: The ACL match rule.
-        :param str name: The ACL name to filter for. ACLs with a matching name are listed.
-        :param str update_at: The date on which the ACL was last updated (RFC 3339 format).
+        :param _builtins.str name: The ACL name to filter for. ACLs with a matching name are listed.
+        :param _builtins.str update_at: The date on which the ACL was last updated (RFC 3339 format).
         """
         pulumi.set(__self__, "actions", actions)
         pulumi.set(__self__, "created_at", created_at)
@@ -871,7 +932,7 @@ class GetAclsAclResult(dict):
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "update_at", update_at)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def actions(self) -> Sequence['outputs.GetAclsAclActionResult']:
         """
@@ -879,49 +940,49 @@ class GetAclsAclResult(dict):
         """
         return pulumi.get(self, "actions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         The date on which the ACL was created (RFC 3339 format).
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> str:
+    def description(self) -> _builtins.str:
         """
         The description of the ACL resource.
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="frontendId")
-    def frontend_id(self) -> str:
+    def frontend_id(self) -> _builtins.str:
         """
         The frontend ID this ACL is attached to. ACLs with a matching frontend ID are listed.
         > **Important:** LB frontend IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
         """
         return pulumi.get(self, "frontend_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The associated ACL ID.
         > **Important:** LB ACLs' IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def index(self) -> int:
+    def index(self) -> _builtins.int:
         """
         The priority of this ACL in the ordered list.
         """
         return pulumi.get(self, "index")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def matches(self) -> Sequence['outputs.GetAclsAclMatchResult']:
         """
@@ -929,17 +990,17 @@ class GetAclsAclResult(dict):
         """
         return pulumi.get(self, "matches")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The ACL name to filter for. ACLs with a matching name are listed.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updateAt")
-    def update_at(self) -> str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the ACL was last updated (RFC 3339 format).
         """
@@ -950,15 +1011,15 @@ class GetAclsAclResult(dict):
 class GetAclsAclActionResult(dict):
     def __init__(__self__, *,
                  redirects: Sequence['outputs.GetAclsAclActionRedirectResult'],
-                 type: str):
+                 type: _builtins.str):
         """
         :param Sequence['GetAclsAclActionRedirectArgs'] redirects: Redirect parameters when using an ACL with `redirect` action.
-        :param str type: The redirect type.
+        :param _builtins.str type: The redirect type.
         """
         pulumi.set(__self__, "redirects", redirects)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def redirects(self) -> Sequence['outputs.GetAclsAclActionRedirectResult']:
         """
@@ -966,9 +1027,9 @@ class GetAclsAclActionResult(dict):
         """
         return pulumi.get(self, "redirects")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The redirect type.
         """
@@ -978,37 +1039,37 @@ class GetAclsAclActionResult(dict):
 @pulumi.output_type
 class GetAclsAclActionRedirectResult(dict):
     def __init__(__self__, *,
-                 code: int,
-                 target: str,
-                 type: str):
+                 code: _builtins.int,
+                 target: _builtins.str,
+                 type: _builtins.str):
         """
-        :param int code: The HTTP redirect code to use.
-        :param str target: The URL used in case of a location redirect, or the scheme name that replaces the request's original scheme.
-        :param str type: The redirect type.
+        :param _builtins.int code: The HTTP redirect code to use.
+        :param _builtins.str target: The URL used in case of a location redirect, or the scheme name that replaces the request's original scheme.
+        :param _builtins.str type: The redirect type.
         """
         pulumi.set(__self__, "code", code)
         pulumi.set(__self__, "target", target)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> int:
+    def code(self) -> _builtins.int:
         """
         The HTTP redirect code to use.
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> str:
+    def target(self) -> _builtins.str:
         """
         The URL used in case of a location redirect, or the scheme name that replaces the request's original scheme.
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The redirect type.
         """
@@ -1018,79 +1079,90 @@ class GetAclsAclActionRedirectResult(dict):
 @pulumi.output_type
 class GetAclsAclMatchResult(dict):
     def __init__(__self__, *,
-                 http_filter: str,
-                 http_filter_option: str,
-                 http_filter_values: Sequence[str],
-                 invert: bool,
-                 ip_subnets: Sequence[str]):
-        """
-        :param str http_filter: The HTTP filter to match.
-        :param str http_filter_option: A list of possible values for the HTTP filter based on the HTTP header.
-        :param Sequence[str] http_filter_values: The possible values to match for a given HTTP filter.
-        :param bool invert: The condition will be of type "unless" if invert is set to `true`
-        :param Sequence[str] ip_subnets: A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
+                 http_filter: _builtins.str,
+                 http_filter_option: _builtins.str,
+                 http_filter_values: Sequence[_builtins.str],
+                 invert: _builtins.bool,
+                 ip_subnets: Sequence[_builtins.str],
+                 ips_edge_services: _builtins.bool):
+        """
+        :param _builtins.str http_filter: The HTTP filter to match.
+        :param _builtins.str http_filter_option: A list of possible values for the HTTP filter based on the HTTP header.
+        :param Sequence[_builtins.str] http_filter_values: The possible values to match for a given HTTP filter.
+        :param _builtins.bool invert: The condition will be of type "unless" if invert is set to `true`
+        :param Sequence[_builtins.str] ip_subnets: A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
+        :param _builtins.bool ips_edge_services: Defines whether Edge Services IPs should be matched.
         """
         pulumi.set(__self__, "http_filter", http_filter)
         pulumi.set(__self__, "http_filter_option", http_filter_option)
         pulumi.set(__self__, "http_filter_values", http_filter_values)
         pulumi.set(__self__, "invert", invert)
         pulumi.set(__self__, "ip_subnets", ip_subnets)
+        pulumi.set(__self__, "ips_edge_services", ips_edge_services)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilter")
-    def http_filter(self) -> str:
+    def http_filter(self) -> _builtins.str:
         """
         The HTTP filter to match.
         """
         return pulumi.get(self, "http_filter")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterOption")
-    def http_filter_option(self) -> str:
+    def http_filter_option(self) -> _builtins.str:
         """
         A list of possible values for the HTTP filter based on the HTTP header.
         """
         return pulumi.get(self, "http_filter_option")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterValues")
-    def http_filter_values(self) -> Sequence[str]:
+    def http_filter_values(self) -> Sequence[_builtins.str]:
         """
         The possible values to match for a given HTTP filter.
         """
         return pulumi.get(self, "http_filter_values")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def invert(self) -> bool:
+    def invert(self) -> _builtins.bool:
         """
         The condition will be of type "unless" if invert is set to `true`
         """
         return pulumi.get(self, "invert")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipSubnets")
-    def ip_subnets(self) -> Sequence[str]:
+    def ip_subnets(self) -> Sequence[_builtins.str]:
         """
         A list of IPs, or CIDR v4/v6 addresses of the session client, to match.
         """
         return pulumi.get(self, "ip_subnets")
 
+    @_builtins.property
+    @pulumi.getter(name="ipsEdgeServices")
+    def ips_edge_services(self) -> _builtins.bool:
+        """
+        Defines whether Edge Services IPs should be matched.
+        """
+        return pulumi.get(self, "ips_edge_services")
+
 
 @pulumi.output_type
 class GetBackendHealthCheckHttpResult(dict):
     def __init__(__self__, *,
-                 code: int,
-                 host_header: str,
-                 method: str,
-                 sni: str,
-                 uri: str):
-        """
-        :param int code: The expected HTTP status code
-        :param str host_header: The HTTP host header to use for HC requests
-        :param str method: The HTTP method to use for HC requests
-        :param str sni: The SNI to use for HC requests over SSL
-        :param str uri: The HTTPS endpoint URL to call for HC requests
+                 code: _builtins.int,
+                 host_header: _builtins.str,
+                 method: _builtins.str,
+                 sni: _builtins.str,
+                 uri: _builtins.str):
+        """
+        :param _builtins.int code: The expected HTTP status code
+        :param _builtins.str host_header: The HTTP host header to use for HC requests
+        :param _builtins.str method: The HTTP method to use for HC requests
+        :param _builtins.str sni: The SNI to use for HC requests over SSL
+        :param _builtins.str uri: The HTTPS endpoint URL to call for HC requests
         """
         pulumi.set(__self__, "code", code)
         pulumi.set(__self__, "host_header", host_header)
@@ -1098,41 +1170,41 @@ class GetBackendHealthCheckHttpResult(dict):
         pulumi.set(__self__, "sni", sni)
         pulumi.set(__self__, "uri", uri)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> int:
+    def code(self) -> _builtins.int:
         """
         The expected HTTP status code
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostHeader")
-    def host_header(self) -> str:
+    def host_header(self) -> _builtins.str:
         """
         The HTTP host header to use for HC requests
         """
         return pulumi.get(self, "host_header")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def method(self) -> str:
+    def method(self) -> _builtins.str:
         """
         The HTTP method to use for HC requests
         """
         return pulumi.get(self, "method")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def sni(self) -> str:
+    def sni(self) -> _builtins.str:
         """
         The SNI to use for HC requests over SSL
         """
         return pulumi.get(self, "sni")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> str:
+    def uri(self) -> _builtins.str:
         """
         The HTTPS endpoint URL to call for HC requests
         """
@@ -1148,59 +1220,59 @@ class GetBackendHealthCheckTcpResult(dict):
 @pulumi.output_type
 class GetBackendsBackendResult(dict):
     def __init__(__self__, *,
-                 created_at: str,
-                 failover_host: str,
-                 forward_port: int,
-                 forward_port_algorithm: str,
-                 forward_protocol: str,
-                 health_check_delay: str,
+                 created_at: _builtins.str,
+                 failover_host: _builtins.str,
+                 forward_port: _builtins.int,
+                 forward_port_algorithm: _builtins.str,
+                 forward_protocol: _builtins.str,
+                 health_check_delay: _builtins.str,
                  health_check_http: Sequence['outputs.GetBackendsBackendHealthCheckHttpResult'],
                  health_check_https: Sequence['outputs.GetBackendsBackendHealthCheckHttpResult'],
-                 health_check_max_retries: int,
-                 health_check_port: int,
+                 health_check_max_retries: _builtins.int,
+                 health_check_port: _builtins.int,
                  health_check_tcps: Sequence['outputs.GetBackendsBackendHealthCheckTcpResult'],
-                 health_check_timeout: str,
-                 id: str,
-                 ignore_ssl_server_verify: bool,
-                 lb_id: str,
-                 name: str,
-                 on_marked_down_action: str,
-                 proxy_protocol: str,
-                 server_ips: Sequence[str],
-                 ssl_bridging: bool,
-                 sticky_sessions: str,
-                 sticky_sessions_cookie_name: str,
-                 timeout_connect: str,
-                 timeout_server: str,
-                 timeout_tunnel: str,
-                 update_at: str):
-        """
-        :param str created_at: The date on which the backend was created (RFC 3339 format).
-        :param str failover_host: Scaleway S3 bucket website to be served if all backend servers are down.
-        :param int forward_port: User sessions will be forwarded to this backend server port.
-        :param str forward_port_algorithm: Load balancing algorithm.
-        :param str forward_protocol: Backend protocol.
-        :param str health_check_delay: Interval between two health check requests.
+                 health_check_timeout: _builtins.str,
+                 id: _builtins.str,
+                 ignore_ssl_server_verify: _builtins.bool,
+                 lb_id: _builtins.str,
+                 name: _builtins.str,
+                 on_marked_down_action: _builtins.str,
+                 proxy_protocol: _builtins.str,
+                 server_ips: Sequence[_builtins.str],
+                 ssl_bridging: _builtins.bool,
+                 sticky_sessions: _builtins.str,
+                 sticky_sessions_cookie_name: _builtins.str,
+                 timeout_connect: _builtins.str,
+                 timeout_server: _builtins.str,
+                 timeout_tunnel: _builtins.str,
+                 update_at: _builtins.str):
+        """
+        :param _builtins.str created_at: The date on which the backend was created (RFC 3339 format).
+        :param _builtins.str failover_host: Scaleway S3 bucket website to be served if all backend servers are down.
+        :param _builtins.int forward_port: User sessions will be forwarded to this backend server port.
+        :param _builtins.str forward_port_algorithm: Load balancing algorithm.
+        :param _builtins.str forward_protocol: Backend protocol.
+        :param _builtins.str health_check_delay: Interval between two health check requests.
         :param Sequence['GetBackendsBackendHealthCheckHttpArgs'] health_check_http: This block enables HTTP health checks.
         :param Sequence['GetBackendsBackendHealthCheckHttpArgs'] health_check_https: This block enables HTTPS health checks.
-        :param int health_check_max_retries: Number of allowed failed health check requests before the backend server is marked as down.
-        :param int health_check_port: Port the health check requests will be sent to.
+        :param _builtins.int health_check_max_retries: Number of allowed failed health check requests before the backend server is marked as down.
+        :param _builtins.int health_check_port: Port the health check requests will be sent to.
         :param Sequence['GetBackendsBackendHealthCheckTcpArgs'] health_check_tcps: This block enables TCP health checks.
-        :param str health_check_timeout: Timeout before a health check request is considered failed.
-        :param str id: The associated backend ID.
-        :param bool ignore_ssl_server_verify: Specifies whether the Load Balancer should check the backend server’s certificate before initiating a connection.
-        :param str lb_id: The Load Balancer ID this backend is attached to. Backends with a matching ID are listed.
-        :param str name: The backend name to filter for. Backends with a matching name are listed.
-        :param str on_marked_down_action: Modify what occurs when a backend server is marked down.
-        :param str proxy_protocol: The type of PROXY protocol.
-        :param Sequence[str] server_ips: List of backend server IP addresses.
-        :param bool ssl_bridging: Enables SSL between Load Balancer and backend servers.
-        :param str sticky_sessions: Enables cookie-based session persistence.
-        :param str sticky_sessions_cookie_name: Cookie name for sticky sessions.
-        :param str timeout_connect: Maximum initial server connection establishment time.
-        :param str timeout_server: Maximum server connection inactivity time.
-        :param str timeout_tunnel: Maximum tunnel inactivity time.
-        :param str update_at: The date on which the backend was last updated (RFC 3339 format).
+        :param _builtins.str health_check_timeout: Timeout before a health check request is considered failed.
+        :param _builtins.str id: The associated backend ID.
+        :param _builtins.bool ignore_ssl_server_verify: Specifies whether the Load Balancer should check the backend server’s certificate before initiating a connection.
+        :param _builtins.str lb_id: The Load Balancer ID this backend is attached to. Backends with a matching ID are listed.
+        :param _builtins.str name: The backend name to filter for. Backends with a matching name are listed.
+        :param _builtins.str on_marked_down_action: Modify what occurs when a backend server is marked down.
+        :param _builtins.str proxy_protocol: The type of PROXY protocol.
+        :param Sequence[_builtins.str] server_ips: List of backend server IP addresses.
+        :param _builtins.bool ssl_bridging: Enables SSL between Load Balancer and backend servers.
+        :param _builtins.str sticky_sessions: Enables cookie-based session persistence.
+        :param _builtins.str sticky_sessions_cookie_name: Cookie name for sticky sessions.
+        :param _builtins.str timeout_connect: Maximum initial server connection establishment time.
+        :param _builtins.str timeout_server: Maximum server connection inactivity time.
+        :param _builtins.str timeout_tunnel: Maximum tunnel inactivity time.
+        :param _builtins.str update_at: The date on which the backend was last updated (RFC 3339 format).
         """
         pulumi.set(__self__, "created_at", created_at)
         pulumi.set(__self__, "failover_host", failover_host)
@@ -1229,55 +1301,55 @@ class GetBackendsBackendResult(dict):
         pulumi.set(__self__, "timeout_tunnel", timeout_tunnel)
         pulumi.set(__self__, "update_at", update_at)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         The date on which the backend was created (RFC 3339 format).
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="failoverHost")
-    def failover_host(self) -> str:
+    def failover_host(self) -> _builtins.str:
         """
         Scaleway S3 bucket website to be served if all backend servers are down.
         """
         return pulumi.get(self, "failover_host")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="forwardPort")
-    def forward_port(self) -> int:
+    def forward_port(self) -> _builtins.int:
         """
         User sessions will be forwarded to this backend server port.
         """
         return pulumi.get(self, "forward_port")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="forwardPortAlgorithm")
-    def forward_port_algorithm(self) -> str:
+    def forward_port_algorithm(self) -> _builtins.str:
         """
         Load balancing algorithm.
         """
         return pulumi.get(self, "forward_port_algorithm")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="forwardProtocol")
-    def forward_protocol(self) -> str:
+    def forward_protocol(self) -> _builtins.str:
         """
         Backend protocol.
         """
         return pulumi.get(self, "forward_protocol")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckDelay")
-    def health_check_delay(self) -> str:
+    def health_check_delay(self) -> _builtins.str:
         """
         Interval between two health check requests.
         """
         return pulumi.get(self, "health_check_delay")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckHttp")
     def health_check_http(self) -> Sequence['outputs.GetBackendsBackendHealthCheckHttpResult']:
         """
@@ -1285,7 +1357,7 @@ class GetBackendsBackendResult(dict):
         """
         return pulumi.get(self, "health_check_http")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckHttps")
     def health_check_https(self) -> Sequence['outputs.GetBackendsBackendHealthCheckHttpResult']:
         """
@@ -1293,23 +1365,23 @@ class GetBackendsBackendResult(dict):
         """
         return pulumi.get(self, "health_check_https")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckMaxRetries")
-    def health_check_max_retries(self) -> int:
+    def health_check_max_retries(self) -> _builtins.int:
         """
         Number of allowed failed health check requests before the backend server is marked as down.
         """
         return pulumi.get(self, "health_check_max_retries")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckPort")
-    def health_check_port(self) -> int:
+    def health_check_port(self) -> _builtins.int:
         """
         Port the health check requests will be sent to.
         """
         return pulumi.get(self, "health_check_port")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckTcps")
     def health_check_tcps(self) -> Sequence['outputs.GetBackendsBackendHealthCheckTcpResult']:
         """
@@ -1317,121 +1389,121 @@ class GetBackendsBackendResult(dict):
         """
         return pulumi.get(self, "health_check_tcps")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="healthCheckTimeout")
-    def health_check_timeout(self) -> str:
+    def health_check_timeout(self) -> _builtins.str:
         """
         Timeout before a health check request is considered failed.
         """
         return pulumi.get(self, "health_check_timeout")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The associated backend ID.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ignoreSslServerVerify")
-    def ignore_ssl_server_verify(self) -> bool:
+    def ignore_ssl_server_verify(self) -> _builtins.bool:
         """
         Specifies whether the Load Balancer should check the backend server’s certificate before initiating a connection.
         """
         return pulumi.get(self, "ignore_ssl_server_verify")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="lbId")
-    def lb_id(self) -> str:
+    def lb_id(self) -> _builtins.str:
         """
         The Load Balancer ID this backend is attached to. Backends with a matching ID are listed.
         """
         return pulumi.get(self, "lb_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The backend name to filter for. Backends with a matching name are listed.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="onMarkedDownAction")
-    def on_marked_down_action(self) -> str:
+    def on_marked_down_action(self) -> _builtins.str:
         """
         Modify what occurs when a backend server is marked down.
         """
         return pulumi.get(self, "on_marked_down_action")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="proxyProtocol")
-    def proxy_protocol(self) -> str:
+    def proxy_protocol(self) -> _builtins.str:
         """
         The type of PROXY protocol.
         """
         return pulumi.get(self, "proxy_protocol")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="serverIps")
-    def server_ips(self) -> Sequence[str]:
+    def server_ips(self) -> Sequence[_builtins.str]:
         """
         List of backend server IP addresses.
         """
         return pulumi.get(self, "server_ips")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sslBridging")
-    def ssl_bridging(self) -> bool:
+    def ssl_bridging(self) -> _builtins.bool:
         """
         Enables SSL between Load Balancer and backend servers.
         """
         return pulumi.get(self, "ssl_bridging")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="stickySessions")
-    def sticky_sessions(self) -> str:
+    def sticky_sessions(self) -> _builtins.str:
         """
         Enables cookie-based session persistence.
         """
         return pulumi.get(self, "sticky_sessions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="stickySessionsCookieName")
-    def sticky_sessions_cookie_name(self) -> str:
+    def sticky_sessions_cookie_name(self) -> _builtins.str:
         """
         Cookie name for sticky sessions.
         """
         return pulumi.get(self, "sticky_sessions_cookie_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="timeoutConnect")
-    def timeout_connect(self) -> str:
+    def timeout_connect(self) -> _builtins.str:
         """
         Maximum initial server connection establishment time.
         """
         return pulumi.get(self, "timeout_connect")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="timeoutServer")
-    def timeout_server(self) -> str:
+    def timeout_server(self) -> _builtins.str:
         """
         Maximum server connection inactivity time.
         """
         return pulumi.get(self, "timeout_server")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="timeoutTunnel")
-    def timeout_tunnel(self) -> str:
+    def timeout_tunnel(self) -> _builtins.str:
         """
         Maximum tunnel inactivity time.
         """
         return pulumi.get(self, "timeout_tunnel")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updateAt")
-    def update_at(self) -> str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the backend was last updated (RFC 3339 format).
         """
@@ -1441,17 +1513,17 @@ class GetBackendsBackendResult(dict):
 @pulumi.output_type
 class GetBackendsBackendHealthCheckHttpResult(dict):
     def __init__(__self__, *,
-                 code: int,
-                 host_header: str,
-                 method: str,
-                 sni: str,
-                 uri: str):
-        """
-        :param int code: The expected HTTP status code.
-        :param str host_header: The HTTP host header to use for health check requests.
-        :param str method: The HTTP method to use for health check requests.
-        :param str sni: The SNI to use for HC requests over SSL.
-        :param str uri: The path of health check requests.
+                 code: _builtins.int,
+                 host_header: _builtins.str,
+                 method: _builtins.str,
+                 sni: _builtins.str,
+                 uri: _builtins.str):
+        """
+        :param _builtins.int code: The expected HTTP status code.
+        :param _builtins.str host_header: The HTTP host header to use for health check requests.
+        :param _builtins.str method: The HTTP method to use for health check requests.
+        :param _builtins.str sni: The SNI to use for HC requests over SSL.
+        :param _builtins.str uri: The path of health check requests.
         """
         pulumi.set(__self__, "code", code)
         pulumi.set(__self__, "host_header", host_header)
@@ -1459,41 +1531,41 @@ class GetBackendsBackendHealthCheckHttpResult(dict):
         pulumi.set(__self__, "sni", sni)
         pulumi.set(__self__, "uri", uri)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> int:
+    def code(self) -> _builtins.int:
         """
         The expected HTTP status code.
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostHeader")
-    def host_header(self) -> str:
+    def host_header(self) -> _builtins.str:
         """
         The HTTP host header to use for health check requests.
         """
         return pulumi.get(self, "host_header")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def method(self) -> str:
+    def method(self) -> _builtins.str:
         """
         The HTTP method to use for health check requests.
         """
         return pulumi.get(self, "method")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def sni(self) -> str:
+    def sni(self) -> _builtins.str:
         """
         The SNI to use for HC requests over SSL.
         """
         return pulumi.get(self, "sni")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> str:
+    def uri(self) -> _builtins.str:
         """
         The path of health check requests.
         """
@@ -1509,15 +1581,15 @@ class GetBackendsBackendHealthCheckTcpResult(dict):
 @pulumi.output_type
 class GetCertificateCustomCertificateResult(dict):
     def __init__(__self__, *,
-                 certificate_chain: str):
+                 certificate_chain: _builtins.str):
         """
-        :param str certificate_chain: The full PEM-formatted certificate chain
+        :param _builtins.str certificate_chain: The full PEM-formatted certificate chain
         """
         pulumi.set(__self__, "certificate_chain", certificate_chain)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="certificateChain")
-    def certificate_chain(self) -> str:
+    def certificate_chain(self) -> _builtins.str:
         """
         The full PEM-formatted certificate chain
         """
@@ -1527,26 +1599,26 @@ class GetCertificateCustomCertificateResult(dict):
 @pulumi.output_type
 class GetCertificateLetsencryptResult(dict):
     def __init__(__self__, *,
-                 common_name: str,
-                 subject_alternative_names: Sequence[str]):
+                 common_name: _builtins.str,
+                 subject_alternative_names: Sequence[_builtins.str]):
         """
-        :param str common_name: The main domain name of the certificate
-        :param Sequence[str] subject_alternative_names: The alternative domain names of the certificate
+        :param _builtins.str common_name: The main domain name of the certificate
+        :param Sequence[_builtins.str] subject_alternative_names: The alternative domain names of the certificate
         """
         pulumi.set(__self__, "common_name", common_name)
         pulumi.set(__self__, "subject_alternative_names", subject_alternative_names)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="commonName")
-    def common_name(self) -> str:
+    def common_name(self) -> _builtins.str:
         """
         The main domain name of the certificate
         """
         return pulumi.get(self, "common_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="subjectAlternativeNames")
-    def subject_alternative_names(self) -> Sequence[str]:
+    def subject_alternative_names(self) -> Sequence[_builtins.str]:
         """
         The alternative domain names of the certificate
         """
@@ -1557,19 +1629,19 @@ class GetCertificateLetsencryptResult(dict):
 class GetFrontendAclResult(dict):
     def __init__(__self__, *,
                  actions: Sequence['outputs.GetFrontendAclActionResult'],
-                 created_at: str,
-                 description: str,
+                 created_at: _builtins.str,
+                 description: _builtins.str,
                  matches: Sequence['outputs.GetFrontendAclMatchResult'],
-                 name: str,
-                 updated_at: str):
+                 name: _builtins.str,
+                 updated_at: _builtins.str):
         """
         :param Sequence['GetFrontendAclActionArgs'] actions: Action to undertake when an ACL filter matches
-        :param str created_at: IsDate and time of ACL's creation (RFC 3339 format)
-        :param str description: Description of the ACL
+        :param _builtins.str created_at: IsDate and time of ACL's creation (RFC 3339 format)
+        :param _builtins.str description: Description of the ACL
         :param Sequence['GetFrontendAclMatchArgs'] matches: The ACL match rule
-        :param str name: The name of the frontend.
+        :param _builtins.str name: The name of the frontend.
                - When using the `name` you should specify the `lb-id`
-        :param str updated_at: IsDate and time of ACL's update (RFC 3339 format)
+        :param _builtins.str updated_at: IsDate and time of ACL's update (RFC 3339 format)
         """
         pulumi.set(__self__, "actions", actions)
         pulumi.set(__self__, "created_at", created_at)
@@ -1578,7 +1650,7 @@ class GetFrontendAclResult(dict):
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "updated_at", updated_at)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def actions(self) -> Sequence['outputs.GetFrontendAclActionResult']:
         """
@@ -1586,23 +1658,23 @@ class GetFrontendAclResult(dict):
         """
         return pulumi.get(self, "actions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         IsDate and time of ACL's creation (RFC 3339 format)
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> str:
+    def description(self) -> _builtins.str:
         """
         Description of the ACL
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def matches(self) -> Sequence['outputs.GetFrontendAclMatchResult']:
         """
@@ -1610,18 +1682,18 @@ class GetFrontendAclResult(dict):
         """
         return pulumi.get(self, "matches")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The name of the frontend.
         - When using the `name` you should specify the `lb-id`
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updatedAt")
-    def updated_at(self) -> str:
+    def updated_at(self) -> _builtins.str:
         """
         IsDate and time of ACL's update (RFC 3339 format)
         """
@@ -1632,15 +1704,15 @@ class GetFrontendAclResult(dict):
 class GetFrontendAclActionResult(dict):
     def __init__(__self__, *,
                  redirects: Sequence['outputs.GetFrontendAclActionRedirectResult'],
-                 type: str):
+                 type: _builtins.str):
         """
         :param Sequence['GetFrontendAclActionRedirectArgs'] redirects: Redirect parameters when using an ACL with `redirect` action
-        :param str type: The action type
+        :param _builtins.str type: The action type
         """
         pulumi.set(__self__, "redirects", redirects)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def redirects(self) -> Sequence['outputs.GetFrontendAclActionRedirectResult']:
         """
@@ -1648,9 +1720,9 @@ class GetFrontendAclActionResult(dict):
         """
         return pulumi.get(self, "redirects")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The action type
         """
@@ -1660,37 +1732,37 @@ class GetFrontendAclActionResult(dict):
 @pulumi.output_type
 class GetFrontendAclActionRedirectResult(dict):
     def __init__(__self__, *,
-                 code: int,
-                 target: str,
-                 type: str):
+                 code: _builtins.int,
+                 target: _builtins.str,
+                 type: _builtins.str):
         """
-        :param int code: The HTTP redirect code to use
-        :param str target: An URL can be used in case of a location redirect
-        :param str type: The redirect type
+        :param _builtins.int code: The HTTP redirect code to use
+        :param _builtins.str target: An URL can be used in case of a location redirect
+        :param _builtins.str type: The redirect type
         """
         pulumi.set(__self__, "code", code)
         pulumi.set(__self__, "target", target)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> int:
+    def code(self) -> _builtins.int:
         """
         The HTTP redirect code to use
         """
         return pulumi.get(self, "code")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> str:
+    def target(self) -> _builtins.str:
         """
         An URL can be used in case of a location redirect
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The redirect type
         """
@@ -1700,95 +1772,112 @@ class GetFrontendAclActionRedirectResult(dict):
 @pulumi.output_type
 class GetFrontendAclMatchResult(dict):
     def __init__(__self__, *,
-                 http_filter: str,
-                 http_filter_option: str,
-                 http_filter_values: Sequence[str],
-                 invert: bool,
-                 ip_subnets: Sequence[str]):
-        """
-        :param str http_filter: The HTTP filter to match
-        :param str http_filter_option: You can use this field with http_header_match acl type to set the header name to filter
-        :param Sequence[str] http_filter_values: A list of possible values to match for the given HTTP filter
-        :param bool invert: If set to true, the condition will be of type "unless"
-        :param Sequence[str] ip_subnets: A list of IPs or CIDR v4/v6 addresses of the client of the session to match
+                 http_filter: _builtins.str,
+                 http_filter_option: _builtins.str,
+                 http_filter_values: Sequence[_builtins.str],
+                 invert: _builtins.bool,
+                 ip_subnets: Sequence[_builtins.str],
+                 ips_edge_services: _builtins.bool):
+        """
+        :param _builtins.str http_filter: The HTTP filter to match
+        :param _builtins.str http_filter_option: You can use this field with http_header_match acl type to set the header name to filter
+        :param Sequence[_builtins.str] http_filter_values: A list of possible values to match for the given HTTP filter
+        :param _builtins.bool invert: If set to true, the condition will be of type "unless"
+        :param Sequence[_builtins.str] ip_subnets: A list of IPs or CIDR v4/v6 addresses of the client of the session to match
+        :param _builtins.bool ips_edge_services: Defines whether Edge Services IPs should be matched
         """
         pulumi.set(__self__, "http_filter", http_filter)
         pulumi.set(__self__, "http_filter_option", http_filter_option)
         pulumi.set(__self__, "http_filter_values", http_filter_values)
         pulumi.set(__self__, "invert", invert)
         pulumi.set(__self__, "ip_subnets", ip_subnets)
+        pulumi.set(__self__, "ips_edge_services", ips_edge_services)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilter")
-    def http_filter(self) -> str:
+    def http_filter(self) -> _builtins.str:
         """
         The HTTP filter to match
         """
         return pulumi.get(self, "http_filter")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterOption")
-    def http_filter_option(self) -> str:
+    def http_filter_option(self) -> _builtins.str:
         """
         You can use this field with http_header_match acl type to set the header name to filter
         """
         return pulumi.get(self, "http_filter_option")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterValues")
-    def http_filter_values(self) -> Sequence[str]:
+    def http_filter_values(self) -> Sequence[_builtins.str]:
         """
         A list of possible values to match for the given HTTP filter
         """
         return pulumi.get(self, "http_filter_values")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def invert(self) -> bool:
+    def invert(self) -> _builtins.bool:
         """
         If set to true, the condition will be of type "unless"
         """
         return pulumi.get(self, "invert")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipSubnets")
-    def ip_subnets(self) -> Sequence[str]:
+    def ip_subnets(self) -> Sequence[_builtins.str]:
         """
         A list of IPs or CIDR v4/v6 addresses of the client of the session to match
         """
         return pulumi.get(self, "ip_subnets")
 
+    @_builtins.property
+    @pulumi.getter(name="ipsEdgeServices")
+    def ips_edge_services(self) -> _builtins.bool:
+        """
+        Defines whether Edge Services IPs should be matched
+        """
+        return pulumi.get(self, "ips_edge_services")
+
 
 @pulumi.output_type
 class GetFrontendsFrontendResult(dict):
     def __init__(__self__, *,
-                 backend_id: str,
-                 certificate_ids: Sequence[str],
-                 created_at: str,
-                 enable_http3: bool,
-                 id: str,
-                 inbound_port: int,
-                 lb_id: str,
-                 name: str,
-                 timeout_client: str,
-                 update_at: str):
-        """
-        :param str backend_id: The Load Balancer backend ID this frontend is attached to.
+                 backend_id: _builtins.str,
+                 certificate_ids: Sequence[_builtins.str],
+                 connection_rate_limit: _builtins.int,
+                 created_at: _builtins.str,
+                 enable_access_logs: _builtins.bool,
+                 enable_http3: _builtins.bool,
+                 id: _builtins.str,
+                 inbound_port: _builtins.int,
+                 lb_id: _builtins.str,
+                 name: _builtins.str,
+                 timeout_client: _builtins.str,
+                 update_at: _builtins.str):
+        """
+        :param _builtins.str backend_id: The Load Balancer backend ID this frontend is attached to.
                > **Important:** Load Balancer backend IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
-        :param Sequence[str] certificate_ids: List of certificate IDs that are used by the frontend.
-        :param str created_at: The date on which the frontend was created (RFC 3339 format).
-        :param bool enable_http3: Whether HTTP/3 protocol is activated.
-        :param str id: The ID of the associated frontend.
+        :param Sequence[_builtins.str] certificate_ids: List of certificate IDs that are used by the frontend.
+        :param _builtins.int connection_rate_limit: The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
+        :param _builtins.str created_at: The date on which the frontend was created (RFC 3339 format).
+        :param _builtins.bool enable_access_logs: Defines whether to enable access logs on the frontend.
+        :param _builtins.bool enable_http3: Whether HTTP/3 protocol is activated.
+        :param _builtins.str id: The ID of the associated frontend.
                > **Important:** LB frontend IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
-        :param int inbound_port: TCP port the frontend listens to.
-        :param str lb_id: The Load Balancer ID this frontend is attached to. Frontends with a matching ID are listed.
-        :param str name: The frontend name to filter for. Frontends with a matching name are listed.
-        :param str timeout_client: Maximum inactivity time on the client side.
-        :param str update_at: The date aont which the frontend was last updated (RFC 3339 format).
+        :param _builtins.int inbound_port: TCP port the frontend listens to.
+        :param _builtins.str lb_id: The Load Balancer ID this frontend is attached to. Frontends with a matching ID are listed.
+        :param _builtins.str name: The frontend name to filter for. Frontends with a matching name are listed.
+        :param _builtins.str timeout_client: Maximum inactivity time on the client side.
+        :param _builtins.str update_at: The date on which the frontend was last updated (RFC 3339 format).
         """
         pulumi.set(__self__, "backend_id", backend_id)
         pulumi.set(__self__, "certificate_ids", certificate_ids)
+        pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
         pulumi.set(__self__, "created_at", created_at)
+        pulumi.set(__self__, "enable_access_logs", enable_access_logs)
         pulumi.set(__self__, "enable_http3", enable_http3)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "inbound_port", inbound_port)
@@ -1797,85 +1886,101 @@ class GetFrontendsFrontendResult(dict):
         pulumi.set(__self__, "timeout_client", timeout_client)
         pulumi.set(__self__, "update_at", update_at)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="backendId")
-    def backend_id(self) -> str:
+    def backend_id(self) -> _builtins.str:
         """
         The Load Balancer backend ID this frontend is attached to.
         > **Important:** Load Balancer backend IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
         """
         return pulumi.get(self, "backend_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="certificateIds")
-    def certificate_ids(self) -> Sequence[str]:
+    def certificate_ids(self) -> Sequence[_builtins.str]:
         """
         List of certificate IDs that are used by the frontend.
         """
         return pulumi.get(self, "certificate_ids")
 
-    @property
+    @_builtins.property
+    @pulumi.getter(name="connectionRateLimit")
+    def connection_rate_limit(self) -> _builtins.int:
+        """
+        The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
+        """
+        return pulumi.get(self, "connection_rate_limit")
+
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         The date on which the frontend was created (RFC 3339 format).
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
+    @pulumi.getter(name="enableAccessLogs")
+    def enable_access_logs(self) -> _builtins.bool:
+        """
+        Defines whether to enable access logs on the frontend.
+        """
+        return pulumi.get(self, "enable_access_logs")
+
+    @_builtins.property
     @pulumi.getter(name="enableHttp3")
-    def enable_http3(self) -> bool:
+    def enable_http3(self) -> _builtins.bool:
         """
         Whether HTTP/3 protocol is activated.
         """
         return pulumi.get(self, "enable_http3")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The ID of the associated frontend.
         > **Important:** LB frontend IDs are zoned, which means they are of the form `{zone}/{id}`, e.g. `fr-par-1/11111111-1111-1111-1111-111111111111`
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="inboundPort")
-    def inbound_port(self) -> int:
+    def inbound_port(self) -> _builtins.int:
         """
         TCP port the frontend listens to.
         """
         return pulumi.get(self, "inbound_port")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="lbId")
-    def lb_id(self) -> str:
+    def lb_id(self) -> _builtins.str:
         """
         The Load Balancer ID this frontend is attached to. Frontends with a matching ID are listed.
         """
         return pulumi.get(self, "lb_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The frontend name to filter for. Frontends with a matching name are listed.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="timeoutClient")
-    def timeout_client(self) -> str:
+    def timeout_client(self) -> _builtins.str:
         """
         Maximum inactivity time on the client side.
         """
         return pulumi.get(self, "timeout_client")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updateAt")
-    def update_at(self) -> str:
+    def update_at(self) -> _builtins.str:
         """
-        The date aont which the frontend was last updated (RFC 3339 format).
+        The date on which the frontend was last updated (RFC 3339 format).
         """
         return pulumi.get(self, "update_at")
 
@@ -1883,23 +1988,23 @@ class GetFrontendsFrontendResult(dict):
 @pulumi.output_type
 class GetIpsIpResult(dict):
     def __init__(__self__, *,
-                 id: str,
-                 ip_address: str,
-                 lb_id: str,
-                 organization_id: str,
-                 project_id: str,
-                 reverse: str,
-                 tags: Sequence[str],
-                 zone: str):
-        """
-        :param str id: The ID of the associated IP.
-        :param str ip_address: The IP address
-        :param str lb_id: The ID of the associated Load BalancerD, if any
-        :param str organization_id: The ID of the Organization the Load Balancer is associated with.
-        :param str project_id: The ID of the Project the Load Balancer is associated with.
-        :param str reverse: The reverse domain associated with this IP.
-        :param Sequence[str] tags: List of tags used as filter. IPs with these exact tags are listed.
-        :param str zone: `zone`) The zone in which the IPs exist.
+                 id: _builtins.str,
+                 ip_address: _builtins.str,
+                 lb_id: _builtins.str,
+                 organization_id: _builtins.str,
+                 project_id: _builtins.str,
+                 reverse: _builtins.str,
+                 tags: Sequence[_builtins.str],
+                 zone: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str id: The ID of the associated IP.
+        :param _builtins.str ip_address: The IP address
+        :param _builtins.str lb_id: The ID of the associated Load BalancerD, if any
+        :param _builtins.str organization_id: The ID of the Organization the Load Balancer is associated with.
+        :param _builtins.str project_id: The ID of the Project the Load Balancer is associated with.
+        :param _builtins.str reverse: The reverse domain associated with this IP.
+        :param Sequence[_builtins.str] tags: List of tags used as filter. IPs with these exact tags are listed.
+        :param _builtins.str zone: `zone`) The zone in which the IPs exist.
         """
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ip_address", ip_address)
@@ -1908,89 +2013,119 @@ class GetIpsIpResult(dict):
         pulumi.set(__self__, "project_id", project_id)
         pulumi.set(__self__, "reverse", reverse)
         pulumi.set(__self__, "tags", tags)
-        pulumi.set(__self__, "zone", zone)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The ID of the associated IP.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipAddress")
-    def ip_address(self) -> str:
+    def ip_address(self) -> _builtins.str:
         """
         The IP address
         """
         return pulumi.get(self, "ip_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="lbId")
-    def lb_id(self) -> str:
+    def lb_id(self) -> _builtins.str:
         """
         The ID of the associated Load BalancerD, if any
         """
         return pulumi.get(self, "lb_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="organizationId")
-    def organization_id(self) -> str:
+    def organization_id(self) -> _builtins.str:
         """
         The ID of the Organization the Load Balancer is associated with.
         """
         return pulumi.get(self, "organization_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="projectId")
-    def project_id(self) -> str:
+    def project_id(self) -> _builtins.str:
         """
         The ID of the Project the Load Balancer is associated with.
         """
         return pulumi.get(self, "project_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def reverse(self) -> str:
+    def reverse(self) -> _builtins.str:
         """
         The reverse domain associated with this IP.
         """
         return pulumi.get(self, "reverse")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tags(self) -> Sequence[str]:
+    def tags(self) -> Sequence[_builtins.str]:
         """
         List of tags used as filter. IPs with these exact tags are listed.
         """
         return pulumi.get(self, "tags")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def zone(self) -> str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the IPs exist.
         """
         return pulumi.get(self, "zone")
 
 
+@pulumi.output_type
+class GetLoadBalancerPrivateIpResult(dict):
+    def __init__(__self__, *,
+                 address: _builtins.str,
+                 id: _builtins.str):
+        """
+        :param _builtins.str address: The private IP address
+        :param _builtins.str id: The ID of the Load Balancer.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def address(self) -> _builtins.str:
+        """
+        The private IP address
+        """
+        return pulumi.get(self, "address")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Load Balancer.
+        """
+        return pulumi.get(self, "id")
+
+
 @pulumi.output_type
 class GetLoadBalancerPrivateNetworkResult(dict):
     def __init__(__self__, *,
-                 dhcp_config: bool,
-                 ipam_ids: Sequence[str],
-                 private_network_id: str,
-                 static_configs: Sequence[str],
-                 status: str,
-                 zone: str):
-        """
-        :param bool dhcp_config: Set to true if you want to let DHCP assign IP addresses
-        :param Sequence[str] ipam_ids: IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network
-        :param str private_network_id: The Private Network ID
-        :param Sequence[str] static_configs: Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
-        :param str status: The status of private network connection
-        :param str zone: (Defaults to provider `zone`) The zone in which the Load Balancer exists.
+                 dhcp_config: _builtins.bool,
+                 ipam_ids: Sequence[_builtins.str],
+                 private_network_id: _builtins.str,
+                 static_configs: Sequence[_builtins.str],
+                 status: _builtins.str,
+                 zone: _builtins.str):
+        """
+        :param _builtins.bool dhcp_config: Set to true if you want to let DHCP assign IP addresses
+        :param Sequence[_builtins.str] ipam_ids: IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network
+        :param _builtins.str private_network_id: The Private Network ID
+        :param Sequence[_builtins.str] static_configs: Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
+        :param _builtins.str status: The status of private network connection
+        :param _builtins.str zone: (Defaults to provider `zone`) The zone in which the Load Balancer exists.
         """
         pulumi.set(__self__, "dhcp_config", dhcp_config)
         pulumi.set(__self__, "ipam_ids", ipam_ids)
@@ -1999,49 +2134,49 @@ class GetLoadBalancerPrivateNetworkResult(dict):
         pulumi.set(__self__, "status", status)
         pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="dhcpConfig")
-    def dhcp_config(self) -> bool:
+    def dhcp_config(self) -> _builtins.bool:
         """
         Set to true if you want to let DHCP assign IP addresses
         """
         return pulumi.get(self, "dhcp_config")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipamIds")
-    def ipam_ids(self) -> Sequence[str]:
+    def ipam_ids(self) -> Sequence[_builtins.str]:
         """
         IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network
         """
         return pulumi.get(self, "ipam_ids")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="privateNetworkId")
-    def private_network_id(self) -> str:
+    def private_network_id(self) -> _builtins.str:
         """
         The Private Network ID
         """
         return pulumi.get(self, "private_network_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="staticConfigs")
-    def static_configs(self) -> Sequence[str]:
+    def static_configs(self) -> Sequence[_builtins.str]:
         """
         Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
         """
         return pulumi.get(self, "static_configs")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def status(self) -> str:
+    def status(self) -> _builtins.str:
         """
         The status of private network connection
         """
         return pulumi.get(self, "status")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def zone(self) -> str:
+    def zone(self) -> _builtins.str:
         """
         (Defaults to provider `zone`) The zone in which the Load Balancer exists.
         """
@@ -2051,45 +2186,45 @@ class GetLoadBalancerPrivateNetworkResult(dict):
 @pulumi.output_type
 class GetLoadBalancersLbResult(dict):
     def __init__(__self__, *,
-                 backend_count: int,
-                 created_at: str,
-                 description: str,
-                 frontend_count: int,
-                 id: str,
+                 backend_count: _builtins.int,
+                 created_at: _builtins.str,
+                 description: _builtins.str,
+                 frontend_count: _builtins.int,
+                 id: _builtins.str,
                  instances: Sequence['outputs.GetLoadBalancersLbInstanceResult'],
                  ips: Sequence['outputs.GetLoadBalancersLbIpResult'],
-                 name: str,
-                 organization_id: str,
-                 private_network_count: int,
-                 project_id: str,
-                 route_count: int,
-                 ssl_compatibility_level: str,
-                 status: str,
-                 subscriber: str,
-                 tags: Sequence[str],
-                 type: str,
-                 updated_at: str,
-                 zone: str):
-        """
-        :param int backend_count: Number of backends the Load Balancer has.
-        :param str created_at: Date on which the Load Balancer was created.
-        :param str description: The description of the Load Balancer.
-        :param int frontend_count: Number of frontends the Load Balancer has.
-        :param str id: The ID of the Load Balancer.
+                 name: _builtins.str,
+                 organization_id: _builtins.str,
+                 private_network_count: _builtins.int,
+                 project_id: _builtins.str,
+                 route_count: _builtins.int,
+                 ssl_compatibility_level: _builtins.str,
+                 status: _builtins.str,
+                 subscriber: _builtins.str,
+                 tags: Sequence[_builtins.str],
+                 type: _builtins.str,
+                 updated_at: _builtins.str,
+                 zone: Optional[_builtins.str] = None):
+        """
+        :param _builtins.int backend_count: Number of backends the Load Balancer has.
+        :param _builtins.str created_at: Date on which the Load Balancer was created.
+        :param _builtins.str description: The description of the Load Balancer.
+        :param _builtins.int frontend_count: Number of frontends the Load Balancer has.
+        :param _builtins.str id: The ID of the Load Balancer.
         :param Sequence['GetLoadBalancersLbInstanceArgs'] instances: List of underlying Instances.
         :param Sequence['GetLoadBalancersLbIpArgs'] ips: List of IPs attached to the Load Balancer.
-        :param str name: The Load Balancer name to filter for. Load Balancers with a matching name are listed.
-        :param str organization_id: The ID of the Organization the Load Balancer is associated with.
-        :param int private_network_count: Number of Private Networks attached to the Load balancer.
-        :param str project_id: The ID of the Project the Load Balancer is associated with.
-        :param int route_count: Number of routes the Load balancer has.
-        :param str ssl_compatibility_level: Determines the minimal SSL version which needs to be supported on the client side.
-        :param str status: The state of the Load Balancer Instance. Possible values are: `unknown`, `ready`, `pending`, `stopped`, `error`, `locked` and `migrating`.
-        :param str subscriber: The subscriber information.
-        :param Sequence[str] tags: List of tags to filter for. Load Balancers with these exact tags are listed.
-        :param str type: The offer type of the Load Balancer.
-        :param str updated_at: Date on which the Load Balancer was updated.
-        :param str zone: `zone`) The zone in which the Load Balancers exist.
+        :param _builtins.str name: The Load Balancer name to filter for. Load Balancers with a matching name are listed.
+        :param _builtins.str organization_id: The ID of the Organization the Load Balancer is associated with.
+        :param _builtins.int private_network_count: Number of Private Networks attached to the Load balancer.
+        :param _builtins.str project_id: The ID of the Project the Load Balancer is associated with.
+        :param _builtins.int route_count: Number of routes the Load balancer has.
+        :param _builtins.str ssl_compatibility_level: Determines the minimal SSL version which needs to be supported on the client side.
+        :param _builtins.str status: The state of the Load Balancer Instance. Possible values are: `unknown`, `ready`, `pending`, `stopped`, `error`, `locked` and `migrating`.
+        :param _builtins.str subscriber: The subscriber information.
+        :param Sequence[_builtins.str] tags: List of tags to filter for. Load Balancers with these exact tags are listed.
+        :param _builtins.str type: The offer type of the Load Balancer.
+        :param _builtins.str updated_at: Date on which the Load Balancer was updated.
+        :param _builtins.str zone: `zone`) The zone in which the Load Balancers exist.
         """
         pulumi.set(__self__, "backend_count", backend_count)
         pulumi.set(__self__, "created_at", created_at)
@@ -2109,49 +2244,50 @@ class GetLoadBalancersLbResult(dict):
         pulumi.set(__self__, "tags", tags)
         pulumi.set(__self__, "type", type)
         pulumi.set(__self__, "updated_at", updated_at)
-        pulumi.set(__self__, "zone", zone)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="backendCount")
-    def backend_count(self) -> int:
+    def backend_count(self) -> _builtins.int:
         """
         Number of backends the Load Balancer has.
         """
         return pulumi.get(self, "backend_count")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         Date on which the Load Balancer was created.
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> str:
+    def description(self) -> _builtins.str:
         """
         The description of the Load Balancer.
         """
         return pulumi.get(self, "description")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="frontendCount")
-    def frontend_count(self) -> int:
+    def frontend_count(self) -> _builtins.int:
         """
         Number of frontends the Load Balancer has.
         """
         return pulumi.get(self, "frontend_count")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The ID of the Load Balancer.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def instances(self) -> Sequence['outputs.GetLoadBalancersLbInstanceResult']:
         """
@@ -2159,7 +2295,7 @@ class GetLoadBalancersLbResult(dict):
         """
         return pulumi.get(self, "instances")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def ips(self) -> Sequence['outputs.GetLoadBalancersLbIpResult']:
         """
@@ -2167,97 +2303,97 @@ class GetLoadBalancersLbResult(dict):
         """
         return pulumi.get(self, "ips")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The Load Balancer name to filter for. Load Balancers with a matching name are listed.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="organizationId")
-    def organization_id(self) -> str:
+    def organization_id(self) -> _builtins.str:
         """
         The ID of the Organization the Load Balancer is associated with.
         """
         return pulumi.get(self, "organization_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="privateNetworkCount")
-    def private_network_count(self) -> int:
+    def private_network_count(self) -> _builtins.int:
         """
         Number of Private Networks attached to the Load balancer.
         """
         return pulumi.get(self, "private_network_count")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="projectId")
-    def project_id(self) -> str:
+    def project_id(self) -> _builtins.str:
         """
         The ID of the Project the Load Balancer is associated with.
         """
         return pulumi.get(self, "project_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="routeCount")
-    def route_count(self) -> int:
+    def route_count(self) -> _builtins.int:
         """
         Number of routes the Load balancer has.
         """
         return pulumi.get(self, "route_count")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sslCompatibilityLevel")
-    def ssl_compatibility_level(self) -> str:
+    def ssl_compatibility_level(self) -> _builtins.str:
         """
         Determines the minimal SSL version which needs to be supported on the client side.
         """
         return pulumi.get(self, "ssl_compatibility_level")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def status(self) -> str:
+    def status(self) -> _builtins.str:
         """
         The state of the Load Balancer Instance. Possible values are: `unknown`, `ready`, `pending`, `stopped`, `error`, `locked` and `migrating`.
         """
         return pulumi.get(self, "status")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def subscriber(self) -> str:
+    def subscriber(self) -> _builtins.str:
         """
         The subscriber information.
         """
         return pulumi.get(self, "subscriber")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tags(self) -> Sequence[str]:
+    def tags(self) -> Sequence[_builtins.str]:
         """
         List of tags to filter for. Load Balancers with these exact tags are listed.
         """
         return pulumi.get(self, "tags")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The offer type of the Load Balancer.
         """
         return pulumi.get(self, "type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updatedAt")
-    def updated_at(self) -> str:
+    def updated_at(self) -> _builtins.str:
         """
         Date on which the Load Balancer was updated.
         """
         return pulumi.get(self, "updated_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def zone(self) -> str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the Load Balancers exist.
         """
@@ -2267,66 +2403,71 @@ class GetLoadBalancersLbResult(dict):
 @pulumi.output_type
 class GetLoadBalancersLbInstanceResult(dict):
     def __init__(__self__, *,
-                 created_at: str,
-                 id: str,
-                 ip_address: str,
-                 status: str,
-                 updated_at: str,
-                 zone: str):
-        """
-        :param str created_at: Date on which the Load Balancer was created.
-        :param str id: The ID of the Load Balancer.
-        :param str status: The state of the Load Balancer Instance. Possible values are: `unknown`, `ready`, `pending`, `stopped`, `error`, `locked` and `migrating`.
-        :param str updated_at: Date on which the Load Balancer was updated.
-        :param str zone: `zone`) The zone in which the Load Balancers exist.
+                 created_at: _builtins.str,
+                 id: _builtins.str,
+                 ip_address: _builtins.str,
+                 status: _builtins.str,
+                 updated_at: _builtins.str,
+                 zone: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str created_at: Date on which the Load Balancer was created.
+        :param _builtins.str id: The ID of the Load Balancer.
+        :param _builtins.str ip_address: IP address of the instance
+        :param _builtins.str status: The state of the Load Balancer Instance. Possible values are: `unknown`, `ready`, `pending`, `stopped`, `error`, `locked` and `migrating`.
+        :param _builtins.str updated_at: Date on which the Load Balancer was updated.
+        :param _builtins.str zone: `zone`) The zone in which the Load Balancers exist.
         """
         pulumi.set(__self__, "created_at", created_at)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ip_address", ip_address)
         pulumi.set(__self__, "status", status)
         pulumi.set(__self__, "updated_at", updated_at)
-        pulumi.set(__self__, "zone", zone)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         Date on which the Load Balancer was created.
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The ID of the Load Balancer.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipAddress")
-    def ip_address(self) -> str:
+    def ip_address(self) -> _builtins.str:
+        """
+        IP address of the instance
+        """
         return pulumi.get(self, "ip_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def status(self) -> str:
+    def status(self) -> _builtins.str:
         """
         The state of the Load Balancer Instance. Possible values are: `unknown`, `ready`, `pending`, `stopped`, `error`, `locked` and `migrating`.
         """
         return pulumi.get(self, "status")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updatedAt")
-    def updated_at(self) -> str:
+    def updated_at(self) -> _builtins.str:
         """
         Date on which the Load Balancer was updated.
         """
         return pulumi.get(self, "updated_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def zone(self) -> str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the Load Balancers exist.
         """
@@ -2336,18 +2477,21 @@ class GetLoadBalancersLbInstanceResult(dict):
 @pulumi.output_type
 class GetLoadBalancersLbIpResult(dict):
     def __init__(__self__, *,
-                 id: str,
-                 ip_address: str,
-                 lb_id: str,
-                 organization_id: str,
-                 project_id: str,
-                 reverse: str,
-                 zone: str):
-        """
-        :param str id: The ID of the Load Balancer.
-        :param str organization_id: The ID of the Organization the Load Balancer is associated with.
-        :param str project_id: The ID of the Project the Load Balancer is associated with.
-        :param str zone: `zone`) The zone in which the Load Balancers exist.
+                 id: _builtins.str,
+                 ip_address: _builtins.str,
+                 lb_id: _builtins.str,
+                 organization_id: _builtins.str,
+                 project_id: _builtins.str,
+                 reverse: _builtins.str,
+                 zone: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str id: The ID of the Load Balancer.
+        :param _builtins.str ip_address: IP address
+        :param _builtins.str lb_id: UUID of the load balancer attached to the IP
+        :param _builtins.str organization_id: The ID of the Organization the Load Balancer is associated with.
+        :param _builtins.str project_id: The ID of the Project the Load Balancer is associated with.
+        :param _builtins.str reverse: Reverse DNS attached to the IP
+        :param _builtins.str zone: `zone`) The zone in which the Load Balancers exist.
         """
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ip_address", ip_address)
@@ -2355,50 +2499,60 @@ class GetLoadBalancersLbIpResult(dict):
         pulumi.set(__self__, "organization_id", organization_id)
         pulumi.set(__self__, "project_id", project_id)
         pulumi.set(__self__, "reverse", reverse)
-        pulumi.set(__self__, "zone", zone)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The ID of the Load Balancer.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipAddress")
-    def ip_address(self) -> str:
+    def ip_address(self) -> _builtins.str:
+        """
+        IP address
+        """
         return pulumi.get(self, "ip_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="lbId")
-    def lb_id(self) -> str:
+    def lb_id(self) -> _builtins.str:
+        """
+        UUID of the load balancer attached to the IP
+        """
         return pulumi.get(self, "lb_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="organizationId")
-    def organization_id(self) -> str:
+    def organization_id(self) -> _builtins.str:
         """
         The ID of the Organization the Load Balancer is associated with.
         """
         return pulumi.get(self, "organization_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="projectId")
-    def project_id(self) -> str:
+    def project_id(self) -> _builtins.str:
         """
         The ID of the Project the Load Balancer is associated with.
         """
         return pulumi.get(self, "project_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def reverse(self) -> str:
+    def reverse(self) -> _builtins.str:
+        """
+        Reverse DNS attached to the IP
+        """
         return pulumi.get(self, "reverse")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def zone(self) -> str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the Load Balancers exist.
         """
@@ -2408,23 +2562,23 @@ class GetLoadBalancersLbIpResult(dict):
 @pulumi.output_type
 class GetRoutesRouteResult(dict):
     def __init__(__self__, *,
-                 backend_id: str,
-                 created_at: str,
-                 frontend_id: str,
-                 id: str,
-                 match_host_header: str,
-                 match_sni: str,
-                 match_subdomains: bool,
-                 update_at: str):
-        """
-        :param str backend_id: The backend ID to redirect to
-        :param str created_at: The date on which the route was created (RFC 3339 format).
-        :param str frontend_id: The frontend ID (the origin of the redirection), to filter for. Routes with a matching frontend ID are listed.
-        :param str id: The associated route ID.
-        :param str match_host_header: Specifies the host of the server to which the request is being sent.
-        :param str match_sni: Server Name Indication TLS extension field from an incoming connection made via an SSL/TLS transport layer.
-        :param bool match_subdomains: If true, all subdomains will match.
-        :param str update_at: The date on which the route was last updated (RFC 3339 format).
+                 backend_id: _builtins.str,
+                 created_at: _builtins.str,
+                 frontend_id: _builtins.str,
+                 id: _builtins.str,
+                 match_host_header: _builtins.str,
+                 match_sni: _builtins.str,
+                 match_subdomains: _builtins.bool,
+                 update_at: _builtins.str):
+        """
+        :param _builtins.str backend_id: The backend ID to redirect to
+        :param _builtins.str created_at: The date on which the route was created (RFC 3339 format).
+        :param _builtins.str frontend_id: The frontend ID (the origin of the redirection), to filter for. Routes with a matching frontend ID are listed.
+        :param _builtins.str id: The associated route ID.
+        :param _builtins.str match_host_header: Specifies the host of the server to which the request is being sent.
+        :param _builtins.str match_sni: Server Name Indication TLS extension field from an incoming connection made via an SSL/TLS transport layer.
+        :param _builtins.bool match_subdomains: If true, all subdomains will match.
+        :param _builtins.str update_at: The date on which the route was last updated (RFC 3339 format).
         """
         pulumi.set(__self__, "backend_id", backend_id)
         pulumi.set(__self__, "created_at", created_at)
@@ -2435,65 +2589,65 @@ class GetRoutesRouteResult(dict):
         pulumi.set(__self__, "match_subdomains", match_subdomains)
         pulumi.set(__self__, "update_at", update_at)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="backendId")
-    def backend_id(self) -> str:
+    def backend_id(self) -> _builtins.str:
         """
         The backend ID to redirect to
         """
         return pulumi.get(self, "backend_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> str:
+    def created_at(self) -> _builtins.str:
         """
         The date on which the route was created (RFC 3339 format).
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="frontendId")
-    def frontend_id(self) -> str:
+    def frontend_id(self) -> _builtins.str:
         """
         The frontend ID (the origin of the redirection), to filter for. Routes with a matching frontend ID are listed.
         """
         return pulumi.get(self, "frontend_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The associated route ID.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="matchHostHeader")
-    def match_host_header(self) -> str:
+    def match_host_header(self) -> _builtins.str:
         """
         Specifies the host of the server to which the request is being sent.
         """
         return pulumi.get(self, "match_host_header")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="matchSni")
-    def match_sni(self) -> str:
+    def match_sni(self) -> _builtins.str:
         """
         Server Name Indication TLS extension field from an incoming connection made via an SSL/TLS transport layer.
         """
         return pulumi.get(self, "match_sni")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="matchSubdomains")
-    def match_subdomains(self) -> bool:
+    def match_subdomains(self) -> _builtins.bool:
         """
         If true, all subdomains will match.
         """
         return pulumi.get(self, "match_subdomains")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="updateAt")
-    def update_at(self) -> str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the route was last updated (RFC 3339 format).
         """