pulumiverse-scaleway 1.35.0a1759392423__py3-none-any.whl → 1.35.0a1760445454__py3-none-any.whl

pulumiverse_scaleway/loadbalancers/outputs.py

@@ -2,8 +2,7 @@
 # *** 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 builtins
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -59,25 +58,25 @@ __all__ = [
 @pulumi.output_type
 class AclAction(dict):
     def __init__(__self__, *,
-                 type: builtins.str,
+                 type: _builtins.str,
                  redirects: Optional[Sequence['outputs.AclActionRedirect']] = None):
         """
-        :param builtins.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) -> builtins.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']]:
         """
@@ -89,13 +88,13 @@ class AclAction(dict):
 @pulumi.output_type
 class AclActionRedirect(dict):
     def __init__(__self__, *,
-                 code: Optional[builtins.int] = None,
-                 target: Optional[builtins.str] = None,
-                 type: Optional[builtins.str] = None):
+                 code: Optional[_builtins.int] = None,
+                 target: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
         """
-        :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`.
+        :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)
@@ -104,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[builtins.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[builtins.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[builtins.str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         The redirect type. Possible values are: `location` or `scheme`.
         """
@@ -157,22 +156,22 @@ class AclMatch(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 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.
+                 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 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.
+        :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 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.
+        :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)
@@ -187,9 +186,9 @@ class AclMatch(dict):
         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[builtins.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).
@@ -197,42 +196,42 @@ class AclMatch(dict):
         """
         return pulumi.get(self, "http_filter")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterOption")
-    def http_filter_option(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.str]]:
+    def ip_subnets(self) -> Optional[Sequence[_builtins.str]]:
         """
         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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipsEdgeServices")
-    def ips_edge_services(self) -> Optional[builtins.bool]:
+    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.
         """
@@ -259,15 +258,15 @@ class BackendHealthCheckHttp(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 uri: builtins.str,
-                 code: Optional[builtins.int] = None,
-                 host_header: Optional[builtins.str] = None,
-                 method: Optional[builtins.str] = None):
+                 uri: _builtins.str,
+                 code: Optional[_builtins.int] = None,
+                 host_header: Optional[_builtins.str] = None,
+                 method: Optional[_builtins.str] = None):
         """
-        :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
+        :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:
@@ -277,33 +276,33 @@ class BackendHealthCheckHttp(dict):
         if method is not None:
             pulumi.set(__self__, "method", method)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> builtins.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[builtins.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[builtins.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[builtins.str]:
+    def method(self) -> Optional[_builtins.str]:
         """
         The HTTP method to use for HC requests
         """
@@ -330,17 +329,17 @@ class BackendHealthCheckHttps(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 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
+                 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:
@@ -352,41 +351,41 @@ class BackendHealthCheckHttps(dict):
         if sni is not None:
             pulumi.set(__self__, "sni", sni)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def uri(self) -> builtins.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[builtins.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[builtins.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[builtins.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[builtins.str]:
+    def sni(self) -> Optional[_builtins.str]:
         """
         The SNI to use for HC requests over SSL
         """
@@ -419,15 +418,15 @@ class CertificateCustomCertificate(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 certificate_chain: builtins.str):
+                 certificate_chain: _builtins.str):
         """
-        :param builtins.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) -> builtins.str:
+    def certificate_chain(self) -> _builtins.str:
         """
         The full PEM-formatted certificate chain
         """
@@ -456,27 +455,27 @@ class CertificateLetsencrypt(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 common_name: builtins.str,
-                 subject_alternative_names: Optional[Sequence[builtins.str]] = None):
+                 common_name: _builtins.str,
+                 subject_alternative_names: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str common_name: Main domain of the certificate
-        :param Sequence[builtins.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) -> builtins.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[builtins.str]]:
+    def subject_alternative_names(self) -> Optional[Sequence[_builtins.str]]:
         """
         The alternative domain names of the certificate
         """
@@ -507,17 +506,17 @@ class FrontendAcl(dict):
     def __init__(__self__, *,
                  action: 'outputs.FrontendAclAction',
                  match: 'outputs.FrontendAclMatch',
-                 created_at: Optional[builtins.str] = None,
-                 description: Optional[builtins.str] = None,
-                 name: Optional[builtins.str] = None,
-                 updated_at: Optional[builtins.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 `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.
+        :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)
@@ -530,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':
         """
@@ -538,7 +537,7 @@ class FrontendAcl(dict):
         """
         return pulumi.get(self, "action")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def match(self) -> 'outputs.FrontendAclMatch':
         """
@@ -546,33 +545,33 @@ class FrontendAcl(dict):
         """
         return pulumi.get(self, "match")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> Optional[builtins.str]:
+    def created_at(self) -> Optional[_builtins.str]:
         """
         The date and time the frontend was created.
         """
         return pulumi.get(self, "created_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def description(self) -> Optional[builtins.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[builtins.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[builtins.str]:
+    def updated_at(self) -> Optional[_builtins.str]:
         """
         The date and time the frontend resource was updated.
         """
@@ -582,25 +581,25 @@ class FrontendAcl(dict):
 @pulumi.output_type
 class FrontendAclAction(dict):
     def __init__(__self__, *,
-                 type: builtins.str,
+                 type: _builtins.str,
                  redirects: Optional[Sequence['outputs.FrontendAclActionRedirect']] = None):
         """
-        :param builtins.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) -> builtins.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']]:
         """
@@ -612,13 +611,13 @@ class FrontendAclAction(dict):
 @pulumi.output_type
 class FrontendAclActionRedirect(dict):
     def __init__(__self__, *,
-                 code: Optional[builtins.int] = None,
-                 target: Optional[builtins.str] = None,
-                 type: Optional[builtins.str] = None):
+                 code: Optional[_builtins.int] = None,
+                 target: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
         """
-        :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`.
+        :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)
@@ -627,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[builtins.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[builtins.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[builtins.str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         The redirect type. Possible values are: `location` or `scheme`.
         """
@@ -680,22 +679,22 @@ class FrontendAclMatch(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 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.
+                 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 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.
+        :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 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.
+        :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)
@@ -710,9 +709,9 @@ class FrontendAclMatch(dict):
         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[builtins.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).
@@ -720,42 +719,42 @@ class FrontendAclMatch(dict):
         """
         return pulumi.get(self, "http_filter")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpFilterOption")
-    def http_filter_option(self) -> Optional[builtins.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[builtins.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[builtins.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[builtins.str]]:
+    def ip_subnets(self) -> Optional[Sequence[_builtins.str]]:
         """
         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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipsEdgeServices")
-    def ips_edge_services(self) -> Optional[builtins.bool]:
+    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.
         """
@@ -765,28 +764,28 @@ class FrontendAclMatch(dict):
 @pulumi.output_type
 class LoadBalancerPrivateIp(dict):
     def __init__(__self__, *,
-                 address: Optional[builtins.str] = None,
-                 id: Optional[builtins.str] = None):
+                 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.
+        :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)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def address(self) -> Optional[builtins.str]:
+    def address(self) -> Optional[_builtins.str]:
         """
         The private IP address.
         """
         return pulumi.get(self, "address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> Optional[builtins.str]:
+    def id(self) -> Optional[_builtins.str]:
         """
         The ID of the IP address resource.
         """
@@ -819,20 +818,20 @@ class LoadBalancerPrivateNetwork(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 private_network_id: builtins.str,
-                 dhcp_config: Optional[builtins.bool] = None,
-                 ipam_ids: Optional[builtins.str] = None,
-                 static_config: Optional[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.
+                 private_network_id: _builtins.str,
+                 dhcp_config: Optional[_builtins.bool] = None,
+                 ipam_ids: Optional[_builtins.str] = None,
+                 static_config: Optional[_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 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 builtins.str static_config: 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.
+        :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 _builtins.str static_config: 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:
@@ -846,52 +845,52 @@ class LoadBalancerPrivateNetwork(dict):
         if zone is not None:
             pulumi.set(__self__, "zone", zone)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="privateNetworkId")
-    def private_network_id(self) -> builtins.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[builtins.bool]:
+    def dhcp_config(self) -> Optional[_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) -> Optional[builtins.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
+    @_builtins.property
     @pulumi.getter(name="staticConfig")
     @_utilities.deprecated("""static_config field is deprecated, please use `private_network_id` or `ipam_ids` instead""")
-    def static_config(self) -> Optional[builtins.str]:
+    def static_config(self) -> Optional[_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_config")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def status(self) -> Optional[builtins.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[builtins.str]:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone of the Load Balancer.
         """
@@ -902,26 +901,26 @@ class LoadBalancerPrivateNetwork(dict):
 class GetAclsAclResult(dict):
     def __init__(__self__, *,
                  actions: Sequence['outputs.GetAclsAclActionResult'],
-                 created_at: builtins.str,
-                 description: builtins.str,
-                 frontend_id: builtins.str,
-                 id: builtins.str,
-                 index: builtins.int,
+                 created_at: _builtins.str,
+                 description: _builtins.str,
+                 frontend_id: _builtins.str,
+                 id: _builtins.str,
+                 index: _builtins.int,
                  matches: Sequence['outputs.GetAclsAclMatchResult'],
-                 name: builtins.str,
-                 update_at: builtins.str):
+                 name: _builtins.str,
+                 update_at: _builtins.str):
         """
         :param Sequence['GetAclsAclActionArgs'] actions: The action to be undertaken when an ACL filter matches.
-        :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.
+        :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 builtins.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 builtins.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 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).
+        :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)
@@ -933,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']:
         """
@@ -941,49 +940,49 @@ class GetAclsAclResult(dict):
         """
         return pulumi.get(self, "actions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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']:
         """
@@ -991,17 +990,17 @@ class GetAclsAclResult(dict):
         """
         return pulumi.get(self, "matches")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.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) -> builtins.str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the ACL was last updated (RFC 3339 format).
         """
@@ -1012,15 +1011,15 @@ class GetAclsAclResult(dict):
 class GetAclsAclActionResult(dict):
     def __init__(__self__, *,
                  redirects: Sequence['outputs.GetAclsAclActionRedirectResult'],
-                 type: builtins.str):
+                 type: _builtins.str):
         """
         :param Sequence['GetAclsAclActionRedirectArgs'] redirects: Redirect parameters when using an ACL with `redirect` action.
-        :param builtins.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']:
         """
@@ -1028,9 +1027,9 @@ class GetAclsAclActionResult(dict):
         """
         return pulumi.get(self, "redirects")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         The redirect type.
         """
@@ -1040,37 +1039,37 @@ class GetAclsAclActionResult(dict):
 @pulumi.output_type
 class GetAclsAclActionRedirectResult(dict):
     def __init__(__self__, *,
-                 code: builtins.int,
-                 target: builtins.str,
-                 type: builtins.str):
+                 code: _builtins.int,
+                 target: _builtins.str,
+                 type: _builtins.str):
         """
-        :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.
+        :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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         The redirect type.
         """
@@ -1080,19 +1079,19 @@ class GetAclsAclActionRedirectResult(dict):
 @pulumi.output_type
 class GetAclsAclMatchResult(dict):
     def __init__(__self__, *,
-                 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.
+                 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)
@@ -1101,49 +1100,49 @@ class GetAclsAclMatchResult(dict):
         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) -> builtins.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) -> builtins.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[builtins.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) -> builtins.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[builtins.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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipsEdgeServices")
-    def ips_edge_services(self) -> builtins.bool:
+    def ips_edge_services(self) -> _builtins.bool:
         """
         Defines whether Edge Services IPs should be matched.
         """
@@ -1153,17 +1152,17 @@ class GetAclsAclMatchResult(dict):
 @pulumi.output_type
 class GetBackendHealthCheckHttpResult(dict):
     def __init__(__self__, *,
-                 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
+                 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)
@@ -1171,41 +1170,41 @@ class GetBackendHealthCheckHttpResult(dict):
         pulumi.set(__self__, "sni", sni)
         pulumi.set(__self__, "uri", uri)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def uri(self) -> _builtins.str:
         """
         The HTTPS endpoint URL to call for HC requests
         """
@@ -1221,59 +1220,59 @@ class GetBackendHealthCheckTcpResult(dict):
 @pulumi.output_type
 class GetBackendsBackendResult(dict):
     def __init__(__self__, *,
-                 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,
+                 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: builtins.int,
-                 health_check_port: builtins.int,
+                 health_check_max_retries: _builtins.int,
+                 health_check_port: _builtins.int,
                  health_check_tcps: Sequence['outputs.GetBackendsBackendHealthCheckTcpResult'],
-                 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.
+                 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 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 _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 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).
+        :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)
@@ -1302,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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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']:
         """
@@ -1358,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']:
         """
@@ -1366,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) -> builtins.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) -> builtins.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']:
         """
@@ -1390,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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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[builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the backend was last updated (RFC 3339 format).
         """
@@ -1514,17 +1513,17 @@ class GetBackendsBackendResult(dict):
 @pulumi.output_type
 class GetBackendsBackendHealthCheckHttpResult(dict):
     def __init__(__self__, *,
-                 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.
+                 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)
@@ -1532,41 +1531,41 @@ class GetBackendsBackendHealthCheckHttpResult(dict):
         pulumi.set(__self__, "sni", sni)
         pulumi.set(__self__, "uri", uri)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def code(self) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def uri(self) -> _builtins.str:
         """
         The path of health check requests.
         """
@@ -1582,15 +1581,15 @@ class GetBackendsBackendHealthCheckTcpResult(dict):
 @pulumi.output_type
 class GetCertificateCustomCertificateResult(dict):
     def __init__(__self__, *,
-                 certificate_chain: builtins.str):
+                 certificate_chain: _builtins.str):
         """
-        :param builtins.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) -> builtins.str:
+    def certificate_chain(self) -> _builtins.str:
         """
         The full PEM-formatted certificate chain
         """
@@ -1600,26 +1599,26 @@ class GetCertificateCustomCertificateResult(dict):
 @pulumi.output_type
 class GetCertificateLetsencryptResult(dict):
     def __init__(__self__, *,
-                 common_name: builtins.str,
-                 subject_alternative_names: Sequence[builtins.str]):
+                 common_name: _builtins.str,
+                 subject_alternative_names: Sequence[_builtins.str]):
         """
-        :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
+        :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) -> builtins.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[builtins.str]:
+    def subject_alternative_names(self) -> Sequence[_builtins.str]:
         """
         The alternative domain names of the certificate
         """
@@ -1630,19 +1629,19 @@ class GetCertificateLetsencryptResult(dict):
 class GetFrontendAclResult(dict):
     def __init__(__self__, *,
                  actions: Sequence['outputs.GetFrontendAclActionResult'],
-                 created_at: builtins.str,
-                 description: builtins.str,
+                 created_at: _builtins.str,
+                 description: _builtins.str,
                  matches: Sequence['outputs.GetFrontendAclMatchResult'],
-                 name: builtins.str,
-                 updated_at: builtins.str):
+                 name: _builtins.str,
+                 updated_at: _builtins.str):
         """
         :param Sequence['GetFrontendAclActionArgs'] actions: Action to undertake when an ACL filter matches
-        :param builtins.str created_at: IsDate and time of ACL's creation (RFC 3339 format)
-        :param builtins.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 builtins.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 builtins.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)
@@ -1651,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']:
         """
@@ -1659,23 +1658,23 @@ class GetFrontendAclResult(dict):
         """
         return pulumi.get(self, "actions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> builtins.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) -> builtins.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']:
         """
@@ -1683,18 +1682,18 @@ class GetFrontendAclResult(dict):
         """
         return pulumi.get(self, "matches")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.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) -> builtins.str:
+    def updated_at(self) -> _builtins.str:
         """
         IsDate and time of ACL's update (RFC 3339 format)
         """
@@ -1705,15 +1704,15 @@ class GetFrontendAclResult(dict):
 class GetFrontendAclActionResult(dict):
     def __init__(__self__, *,
                  redirects: Sequence['outputs.GetFrontendAclActionRedirectResult'],
-                 type: builtins.str):
+                 type: _builtins.str):
         """
         :param Sequence['GetFrontendAclActionRedirectArgs'] redirects: Redirect parameters when using an ACL with `redirect` action
-        :param builtins.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']:
         """
@@ -1721,9 +1720,9 @@ class GetFrontendAclActionResult(dict):
         """
         return pulumi.get(self, "redirects")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         The action type
         """
@@ -1733,37 +1732,37 @@ class GetFrontendAclActionResult(dict):
 @pulumi.output_type
 class GetFrontendAclActionRedirectResult(dict):
     def __init__(__self__, *,
-                 code: builtins.int,
-                 target: builtins.str,
-                 type: builtins.str):
+                 code: _builtins.int,
+                 target: _builtins.str,
+                 type: _builtins.str):
         """
-        :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
+        :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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         The redirect type
         """
@@ -1773,19 +1772,19 @@ class GetFrontendAclActionRedirectResult(dict):
 @pulumi.output_type
 class GetFrontendAclMatchResult(dict):
     def __init__(__self__, *,
-                 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
+                 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)
@@ -1794,49 +1793,49 @@ class GetFrontendAclMatchResult(dict):
         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) -> builtins.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) -> builtins.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[builtins.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) -> builtins.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[builtins.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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipsEdgeServices")
-    def ips_edge_services(self) -> builtins.bool:
+    def ips_edge_services(self) -> _builtins.bool:
         """
         Defines whether Edge Services IPs should be matched
         """
@@ -1846,33 +1845,33 @@ class GetFrontendAclMatchResult(dict):
 @pulumi.output_type
 class GetFrontendsFrontendResult(dict):
     def __init__(__self__, *,
-                 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.
+                 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[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.
+        :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 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).
+        :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)
@@ -1887,99 +1886,99 @@ 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) -> builtins.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[builtins.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:
+    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")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="createdAt")
-    def created_at(self) -> builtins.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:
+    def enable_access_logs(self) -> _builtins.bool:
         """
         Defines whether to enable access logs on the frontend.
         """
         return pulumi.get(self, "enable_access_logs")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="enableHttp3")
-    def enable_http3(self) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the frontend was last updated (RFC 3339 format).
         """
@@ -1989,23 +1988,23 @@ class GetFrontendsFrontendResult(dict):
 @pulumi.output_type
 class GetIpsIpResult(dict):
     def __init__(__self__, *,
-                 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: builtins.str):
-        """
-        :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.
+                 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)
@@ -2014,67 +2013,68 @@ 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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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[builtins.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) -> builtins.str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the IPs exist.
         """
@@ -2084,26 +2084,26 @@ class GetIpsIpResult(dict):
 @pulumi.output_type
 class GetLoadBalancerPrivateIpResult(dict):
     def __init__(__self__, *,
-                 address: builtins.str,
-                 id: builtins.str):
+                 address: _builtins.str,
+                 id: _builtins.str):
         """
-        :param builtins.str address: The private IP address
-        :param builtins.str id: The ID of the Load Balancer.
+        :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)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def address(self) -> builtins.str:
+    def address(self) -> _builtins.str:
         """
         The private IP address
         """
         return pulumi.get(self, "address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         The ID of the Load Balancer.
         """
@@ -2113,19 +2113,19 @@ class GetLoadBalancerPrivateIpResult(dict):
 @pulumi.output_type
 class GetLoadBalancerPrivateNetworkResult(dict):
     def __init__(__self__, *,
-                 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.
+                 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)
@@ -2134,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) -> builtins.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[builtins.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) -> builtins.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[builtins.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) -> builtins.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) -> builtins.str:
+    def zone(self) -> _builtins.str:
         """
         (Defaults to provider `zone`) The zone in which the Load Balancer exists.
         """
@@ -2186,45 +2186,45 @@ class GetLoadBalancerPrivateNetworkResult(dict):
 @pulumi.output_type
 class GetLoadBalancersLbResult(dict):
     def __init__(__self__, *,
-                 backend_count: builtins.int,
-                 created_at: builtins.str,
-                 description: builtins.str,
-                 frontend_count: builtins.int,
-                 id: builtins.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: 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: builtins.str):
-        """
-        :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.
+                 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 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.
+        :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)
@@ -2244,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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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']:
         """
@@ -2294,7 +2295,7 @@ class GetLoadBalancersLbResult(dict):
         """
         return pulumi.get(self, "instances")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def ips(self) -> Sequence['outputs.GetLoadBalancersLbIpResult']:
         """
@@ -2302,97 +2303,97 @@ class GetLoadBalancersLbResult(dict):
         """
         return pulumi.get(self, "ips")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def subscriber(self) -> _builtins.str:
         """
         The subscriber information.
         """
         return pulumi.get(self, "subscriber")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tags(self) -> Sequence[builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the Load Balancers exist.
         """
@@ -2402,70 +2403,71 @@ class GetLoadBalancersLbResult(dict):
 @pulumi.output_type
 class GetLoadBalancersLbInstanceResult(dict):
     def __init__(__self__, *,
-                 created_at: builtins.str,
-                 id: builtins.str,
-                 ip_address: builtins.str,
-                 status: builtins.str,
-                 updated_at: builtins.str,
-                 zone: builtins.str):
-        """
-        :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.
+                 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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the Load Balancers exist.
         """
@@ -2475,21 +2477,21 @@ class GetLoadBalancersLbInstanceResult(dict):
 @pulumi.output_type
 class GetLoadBalancersLbIpResult(dict):
     def __init__(__self__, *,
-                 id: builtins.str,
-                 ip_address: builtins.str,
-                 lb_id: builtins.str,
-                 organization_id: builtins.str,
-                 project_id: builtins.str,
-                 reverse: builtins.str,
-                 zone: builtins.str):
-        """
-        :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.
+                 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)
@@ -2497,59 +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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def zone(self) -> Optional[_builtins.str]:
         """
         `zone`) The zone in which the Load Balancers exist.
         """
@@ -2559,23 +2562,23 @@ class GetLoadBalancersLbIpResult(dict):
 @pulumi.output_type
 class GetRoutesRouteResult(dict):
     def __init__(__self__, *,
-                 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).
+                 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)
@@ -2586,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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.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) -> builtins.str:
+    def update_at(self) -> _builtins.str:
         """
         The date on which the route was last updated (RFC 3339 format).
         """