pulumiverse-scaleway 1.32.0a1753171981__py3-none-any.whl → 1.32.0a1754042138__py3-none-any.whl

pulumiverse_scaleway/loadbalancers/frontend.py

@@ -28,6 +28,7 @@ class FrontendArgs:
                  acls: Optional[pulumi.Input[Sequence[pulumi.Input['FrontendAclArgs']]]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  connection_rate_limit: Optional[pulumi.Input[builtins.int]] = None,
+                 enable_access_logs: Optional[pulumi.Input[builtins.bool]] = None,
                  enable_http3: Optional[pulumi.Input[builtins.bool]] = None,
                  external_acls: Optional[pulumi.Input[builtins.bool]] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
@@ -44,6 +45,7 @@ class FrontendArgs:
                
                > **Important:** Certificates are not allowed on port 80.
         :param pulumi.Input[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 pulumi.Input[builtins.bool] enable_access_logs: Defines whether to enable access logs on the frontend.
         :param pulumi.Input[builtins.bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[builtins.bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -59,6 +61,8 @@ class FrontendArgs:
             pulumi.set(__self__, "certificate_ids", certificate_ids)
         if connection_rate_limit is not None:
             pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
+        if enable_access_logs is not None:
+            pulumi.set(__self__, "enable_access_logs", enable_access_logs)
         if enable_http3 is not None:
             pulumi.set(__self__, "enable_http3", enable_http3)
         if external_acls is not None:
@@ -144,6 +148,18 @@ class FrontendArgs:
     def connection_rate_limit(self, value: Optional[pulumi.Input[builtins.int]]):
         pulumi.set(self, "connection_rate_limit", value)
 
+    @property
+    @pulumi.getter(name="enableAccessLogs")
+    def enable_access_logs(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Defines whether to enable access logs on the frontend.
+        """
+        return pulumi.get(self, "enable_access_logs")
+
+    @enable_access_logs.setter
+    def enable_access_logs(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "enable_access_logs", value)
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> Optional[pulumi.Input[builtins.bool]]:
@@ -202,12 +218,15 @@ class _FrontendState:
                  certificate_id: Optional[pulumi.Input[builtins.str]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  connection_rate_limit: Optional[pulumi.Input[builtins.int]] = None,
+                 created_at: Optional[pulumi.Input[builtins.str]] = None,
+                 enable_access_logs: Optional[pulumi.Input[builtins.bool]] = None,
                  enable_http3: Optional[pulumi.Input[builtins.bool]] = None,
                  external_acls: Optional[pulumi.Input[builtins.bool]] = None,
                  inbound_port: Optional[pulumi.Input[builtins.int]] = None,
                  lb_id: Optional[pulumi.Input[builtins.str]] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
-                 timeout_client: Optional[pulumi.Input[builtins.str]] = None):
+                 timeout_client: Optional[pulumi.Input[builtins.str]] = None,
+                 updated_at: Optional[pulumi.Input[builtins.str]] = None):
         """
         Input properties used for looking up and filtering Frontend resources.
         :param pulumi.Input[Sequence[pulumi.Input['FrontendAclArgs']]] acls: A list of ACL rules to apply to the Load Balancer frontend.  Defined below.
@@ -219,6 +238,8 @@ class _FrontendState:
                
                > **Important:** Certificates are not allowed on port 80.
         :param pulumi.Input[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 pulumi.Input[builtins.str] created_at: The date and time the frontend was created.
+        :param pulumi.Input[builtins.bool] enable_access_logs: Defines whether to enable access logs on the frontend.
         :param pulumi.Input[builtins.bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[builtins.bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -226,6 +247,7 @@ class _FrontendState:
         :param pulumi.Input[builtins.str] lb_id: The ID of the Load Balancer this frontend is attached to.
         :param pulumi.Input[builtins.str] name: The ACL name. If not provided it will be randomly generated.
         :param pulumi.Input[builtins.str] timeout_client: Maximum inactivity time on the client side. (e.g. `1s`)
+        :param pulumi.Input[builtins.str] updated_at: The date and time the frontend resource was updated.
         """
         if acls is not None:
             pulumi.set(__self__, "acls", acls)
@@ -240,6 +262,10 @@ class _FrontendState:
             pulumi.set(__self__, "certificate_ids", certificate_ids)
         if connection_rate_limit is not None:
             pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if enable_access_logs is not None:
+            pulumi.set(__self__, "enable_access_logs", enable_access_logs)
         if enable_http3 is not None:
             pulumi.set(__self__, "enable_http3", enable_http3)
         if external_acls is not None:
@@ -252,6 +278,8 @@ class _FrontendState:
             pulumi.set(__self__, "name", name)
         if timeout_client is not None:
             pulumi.set(__self__, "timeout_client", timeout_client)
+        if updated_at is not None:
+            pulumi.set(__self__, "updated_at", updated_at)
 
     @property
     @pulumi.getter
@@ -318,6 +346,30 @@ class _FrontendState:
     def connection_rate_limit(self, value: Optional[pulumi.Input[builtins.int]]):
         pulumi.set(self, "connection_rate_limit", value)
 
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The date and time the frontend was created.
+        """
+        return pulumi.get(self, "created_at")
+
+    @created_at.setter
+    def created_at(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "created_at", value)
+
+    @property
+    @pulumi.getter(name="enableAccessLogs")
+    def enable_access_logs(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Defines whether to enable access logs on the frontend.
+        """
+        return pulumi.get(self, "enable_access_logs")
+
+    @enable_access_logs.setter
+    def enable_access_logs(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "enable_access_logs", value)
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> Optional[pulumi.Input[builtins.bool]]:
@@ -391,6 +443,18 @@ class _FrontendState:
     def timeout_client(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "timeout_client", value)
 
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The date and time the frontend resource was updated.
+        """
+        return pulumi.get(self, "updated_at")
+
+    @updated_at.setter
+    def updated_at(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "updated_at", value)
+
 
 @pulumi.type_token("scaleway:loadbalancers/frontend:Frontend")
 class Frontend(pulumi.CustomResource):
@@ -402,6 +466,7 @@ class Frontend(pulumi.CustomResource):
                  backend_id: Optional[pulumi.Input[builtins.str]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  connection_rate_limit: Optional[pulumi.Input[builtins.int]] = None,
+                 enable_access_logs: Optional[pulumi.Input[builtins.bool]] = None,
                  enable_http3: Optional[pulumi.Input[builtins.bool]] = None,
                  external_acls: Optional[pulumi.Input[builtins.bool]] = None,
                  inbound_port: Optional[pulumi.Input[builtins.int]] = None,
@@ -537,6 +602,7 @@ class Frontend(pulumi.CustomResource):
                
                > **Important:** Certificates are not allowed on port 80.
         :param pulumi.Input[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 pulumi.Input[builtins.bool] enable_access_logs: Defines whether to enable access logs on the frontend.
         :param pulumi.Input[builtins.bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[builtins.bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -688,6 +754,7 @@ class Frontend(pulumi.CustomResource):
                  backend_id: Optional[pulumi.Input[builtins.str]] = None,
                  certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  connection_rate_limit: Optional[pulumi.Input[builtins.int]] = None,
+                 enable_access_logs: Optional[pulumi.Input[builtins.bool]] = None,
                  enable_http3: Optional[pulumi.Input[builtins.bool]] = None,
                  external_acls: Optional[pulumi.Input[builtins.bool]] = None,
                  inbound_port: Optional[pulumi.Input[builtins.int]] = None,
@@ -709,6 +776,7 @@ class Frontend(pulumi.CustomResource):
             __props__.__dict__["backend_id"] = backend_id
             __props__.__dict__["certificate_ids"] = certificate_ids
             __props__.__dict__["connection_rate_limit"] = connection_rate_limit
+            __props__.__dict__["enable_access_logs"] = enable_access_logs
             __props__.__dict__["enable_http3"] = enable_http3
             __props__.__dict__["external_acls"] = external_acls
             if inbound_port is None and not opts.urn:
@@ -720,6 +788,8 @@ class Frontend(pulumi.CustomResource):
             __props__.__dict__["name"] = name
             __props__.__dict__["timeout_client"] = timeout_client
             __props__.__dict__["certificate_id"] = None
+            __props__.__dict__["created_at"] = None
+            __props__.__dict__["updated_at"] = None
         alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="scaleway:index/loadbalancerFrontend:LoadbalancerFrontend")])
         opts = pulumi.ResourceOptions.merge(opts, alias_opts)
         super(Frontend, __self__).__init__(
@@ -737,12 +807,15 @@ class Frontend(pulumi.CustomResource):
             certificate_id: Optional[pulumi.Input[builtins.str]] = None,
             certificate_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
             connection_rate_limit: Optional[pulumi.Input[builtins.int]] = None,
+            created_at: Optional[pulumi.Input[builtins.str]] = None,
+            enable_access_logs: Optional[pulumi.Input[builtins.bool]] = None,
             enable_http3: Optional[pulumi.Input[builtins.bool]] = None,
             external_acls: Optional[pulumi.Input[builtins.bool]] = None,
             inbound_port: Optional[pulumi.Input[builtins.int]] = None,
             lb_id: Optional[pulumi.Input[builtins.str]] = None,
             name: Optional[pulumi.Input[builtins.str]] = None,
-            timeout_client: Optional[pulumi.Input[builtins.str]] = None) -> 'Frontend':
+            timeout_client: Optional[pulumi.Input[builtins.str]] = None,
+            updated_at: Optional[pulumi.Input[builtins.str]] = None) -> 'Frontend':
         """
         Get an existing Frontend resource's state with the given name, id, and optional extra
         properties used to qualify the lookup.
@@ -759,6 +832,8 @@ class Frontend(pulumi.CustomResource):
                
                > **Important:** Certificates are not allowed on port 80.
         :param pulumi.Input[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 pulumi.Input[builtins.str] created_at: The date and time the frontend was created.
+        :param pulumi.Input[builtins.bool] enable_access_logs: Defines whether to enable access logs on the frontend.
         :param pulumi.Input[builtins.bool] enable_http3: Activates HTTP/3 protocol.
         :param pulumi.Input[builtins.bool] external_acls: A boolean to specify whether to use lb_acl.
                If `external_acls` is set to `true`, `acl` can not be set directly in the Load Balancer frontend.
@@ -766,6 +841,7 @@ class Frontend(pulumi.CustomResource):
         :param pulumi.Input[builtins.str] lb_id: The ID of the Load Balancer this frontend is attached to.
         :param pulumi.Input[builtins.str] name: The ACL name. If not provided it will be randomly generated.
         :param pulumi.Input[builtins.str] timeout_client: Maximum inactivity time on the client side. (e.g. `1s`)
+        :param pulumi.Input[builtins.str] updated_at: The date and time the frontend resource was updated.
         """
         opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
 
@@ -776,12 +852,15 @@ class Frontend(pulumi.CustomResource):
         __props__.__dict__["certificate_id"] = certificate_id
         __props__.__dict__["certificate_ids"] = certificate_ids
         __props__.__dict__["connection_rate_limit"] = connection_rate_limit
+        __props__.__dict__["created_at"] = created_at
+        __props__.__dict__["enable_access_logs"] = enable_access_logs
         __props__.__dict__["enable_http3"] = enable_http3
         __props__.__dict__["external_acls"] = external_acls
         __props__.__dict__["inbound_port"] = inbound_port
         __props__.__dict__["lb_id"] = lb_id
         __props__.__dict__["name"] = name
         __props__.__dict__["timeout_client"] = timeout_client
+        __props__.__dict__["updated_at"] = updated_at
         return Frontend(resource_name, opts=opts, __props__=__props__)
 
     @property
@@ -829,6 +908,22 @@ class Frontend(pulumi.CustomResource):
         """
         return pulumi.get(self, "connection_rate_limit")
 
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> pulumi.Output[builtins.str]:
+        """
+        The date and time the frontend was created.
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter(name="enableAccessLogs")
+    def enable_access_logs(self) -> pulumi.Output[Optional[builtins.bool]]:
+        """
+        Defines whether to enable access logs on the frontend.
+        """
+        return pulumi.get(self, "enable_access_logs")
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> pulumi.Output[Optional[builtins.bool]]:
@@ -878,3 +973,11 @@ class Frontend(pulumi.CustomResource):
         """
         return pulumi.get(self, "timeout_client")
 
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> pulumi.Output[builtins.str]:
+        """
+        The date and time the frontend resource was updated.
+        """
+        return pulumi.get(self, "updated_at")
+

pulumiverse_scaleway/loadbalancers/get_frontend.py

@@ -28,7 +28,7 @@ class GetFrontendResult:
     """
     A collection of values returned by getFrontend.
     """
-    def __init__(__self__, acls=None, backend_id=None, certificate_id=None, certificate_ids=None, connection_rate_limit=None, enable_http3=None, external_acls=None, frontend_id=None, id=None, inbound_port=None, lb_id=None, name=None, timeout_client=None):
+    def __init__(__self__, acls=None, backend_id=None, certificate_id=None, certificate_ids=None, connection_rate_limit=None, created_at=None, enable_access_logs=None, enable_http3=None, external_acls=None, frontend_id=None, id=None, inbound_port=None, lb_id=None, name=None, timeout_client=None, updated_at=None):
         if acls and not isinstance(acls, list):
             raise TypeError("Expected argument 'acls' to be a list")
         pulumi.set(__self__, "acls", acls)
@@ -44,6 +44,12 @@ class GetFrontendResult:
         if connection_rate_limit and not isinstance(connection_rate_limit, int):
             raise TypeError("Expected argument 'connection_rate_limit' to be a int")
         pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
+        if created_at and not isinstance(created_at, str):
+            raise TypeError("Expected argument 'created_at' to be a str")
+        pulumi.set(__self__, "created_at", created_at)
+        if enable_access_logs and not isinstance(enable_access_logs, bool):
+            raise TypeError("Expected argument 'enable_access_logs' to be a bool")
+        pulumi.set(__self__, "enable_access_logs", enable_access_logs)
         if enable_http3 and not isinstance(enable_http3, bool):
             raise TypeError("Expected argument 'enable_http3' to be a bool")
         pulumi.set(__self__, "enable_http3", enable_http3)
@@ -68,6 +74,9 @@ class GetFrontendResult:
         if timeout_client and not isinstance(timeout_client, str):
             raise TypeError("Expected argument 'timeout_client' to be a str")
         pulumi.set(__self__, "timeout_client", timeout_client)
+        if updated_at and not isinstance(updated_at, str):
+            raise TypeError("Expected argument 'updated_at' to be a str")
+        pulumi.set(__self__, "updated_at", updated_at)
 
     @property
     @pulumi.getter
@@ -94,6 +103,16 @@ class GetFrontendResult:
     def connection_rate_limit(self) -> builtins.int:
         return pulumi.get(self, "connection_rate_limit")
 
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> builtins.str:
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter(name="enableAccessLogs")
+    def enable_access_logs(self) -> builtins.bool:
+        return pulumi.get(self, "enable_access_logs")
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> builtins.bool:
@@ -137,6 +156,11 @@ class GetFrontendResult:
     def timeout_client(self) -> builtins.str:
         return pulumi.get(self, "timeout_client")
 
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> builtins.str:
+        return pulumi.get(self, "updated_at")
+
 
 class AwaitableGetFrontendResult(GetFrontendResult):
     # pylint: disable=using-constant-test
@@ -149,6 +173,8 @@ class AwaitableGetFrontendResult(GetFrontendResult):
             certificate_id=self.certificate_id,
             certificate_ids=self.certificate_ids,
             connection_rate_limit=self.connection_rate_limit,
+            created_at=self.created_at,
+            enable_access_logs=self.enable_access_logs,
             enable_http3=self.enable_http3,
             external_acls=self.external_acls,
             frontend_id=self.frontend_id,
@@ -156,7 +182,8 @@ class AwaitableGetFrontendResult(GetFrontendResult):
             inbound_port=self.inbound_port,
             lb_id=self.lb_id,
             name=self.name,
-            timeout_client=self.timeout_client)
+            timeout_client=self.timeout_client,
+            updated_at=self.updated_at)
 
 
 def get_frontend(frontend_id: Optional[builtins.str] = None,
@@ -214,6 +241,8 @@ def get_frontend(frontend_id: Optional[builtins.str] = None,
         certificate_id=pulumi.get(__ret__, 'certificate_id'),
         certificate_ids=pulumi.get(__ret__, 'certificate_ids'),
         connection_rate_limit=pulumi.get(__ret__, 'connection_rate_limit'),
+        created_at=pulumi.get(__ret__, 'created_at'),
+        enable_access_logs=pulumi.get(__ret__, 'enable_access_logs'),
         enable_http3=pulumi.get(__ret__, 'enable_http3'),
         external_acls=pulumi.get(__ret__, 'external_acls'),
         frontend_id=pulumi.get(__ret__, 'frontend_id'),
@@ -221,7 +250,8 @@ def get_frontend(frontend_id: Optional[builtins.str] = None,
         inbound_port=pulumi.get(__ret__, 'inbound_port'),
         lb_id=pulumi.get(__ret__, 'lb_id'),
         name=pulumi.get(__ret__, 'name'),
-        timeout_client=pulumi.get(__ret__, 'timeout_client'))
+        timeout_client=pulumi.get(__ret__, 'timeout_client'),
+        updated_at=pulumi.get(__ret__, 'updated_at'))
 def get_frontend_output(frontend_id: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                         lb_id: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                         name: Optional[pulumi.Input[Optional[builtins.str]]] = None,
@@ -276,6 +306,8 @@ def get_frontend_output(frontend_id: Optional[pulumi.Input[Optional[builtins.str
         certificate_id=pulumi.get(__response__, 'certificate_id'),
         certificate_ids=pulumi.get(__response__, 'certificate_ids'),
         connection_rate_limit=pulumi.get(__response__, 'connection_rate_limit'),
+        created_at=pulumi.get(__response__, 'created_at'),
+        enable_access_logs=pulumi.get(__response__, 'enable_access_logs'),
         enable_http3=pulumi.get(__response__, 'enable_http3'),
         external_acls=pulumi.get(__response__, 'external_acls'),
         frontend_id=pulumi.get(__response__, 'frontend_id'),
@@ -283,4 +315,5 @@ def get_frontend_output(frontend_id: Optional[pulumi.Input[Optional[builtins.str
         inbound_port=pulumi.get(__response__, 'inbound_port'),
         lb_id=pulumi.get(__response__, 'lb_id'),
         name=pulumi.get(__response__, 'name'),
-        timeout_client=pulumi.get(__response__, 'timeout_client')))
+        timeout_client=pulumi.get(__response__, 'timeout_client'),
+        updated_at=pulumi.get(__response__, 'updated_at')))

pulumiverse_scaleway/loadbalancers/outputs.py

@@ -514,10 +514,10 @@ class FrontendAcl(dict):
         """
         :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: IsDate and time of ACL's creation (RFC 3339 format)
+        :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: IsDate and time of ACL's update (RFC 3339 format)
+        :param builtins.str updated_at: The date and time the frontend resource was updated.
         """
         pulumi.set(__self__, "action", action)
         pulumi.set(__self__, "match", match)
@@ -550,7 +550,7 @@ class FrontendAcl(dict):
     @pulumi.getter(name="createdAt")
     def created_at(self) -> Optional[builtins.str]:
         """
-        IsDate and time of ACL's creation (RFC 3339 format)
+        The date and time the frontend was created.
         """
         return pulumi.get(self, "created_at")
 
@@ -574,7 +574,7 @@ class FrontendAcl(dict):
     @pulumi.getter(name="updatedAt")
     def updated_at(self) -> Optional[builtins.str]:
         """
-        IsDate and time of ACL's update (RFC 3339 format)
+        The date and time the frontend resource was updated.
         """
         return pulumi.get(self, "updated_at")
 
@@ -828,9 +828,9 @@ class LoadBalancerPrivateNetwork(dict):
         """
         :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: Please use `ipam_ids`. Set to `true` if you want to let DHCP assign IP addresses.
+        :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: Please use `ipam_ids`. Define a local ip address of your choice for the load balancer instance.
+        :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.
         """
@@ -860,7 +860,7 @@ class LoadBalancerPrivateNetwork(dict):
     @_utilities.deprecated("""dhcp_config field is deprecated, please use `private_network_id` or `ipam_ids` instead""")
     def dhcp_config(self) -> Optional[builtins.bool]:
         """
-        Please use `ipam_ids`. Set to `true` if you want to let DHCP assign IP addresses.
+        Set to true if you want to let DHCP assign IP addresses
         """
         return pulumi.get(self, "dhcp_config")
 
@@ -877,7 +877,7 @@ class LoadBalancerPrivateNetwork(dict):
     @_utilities.deprecated("""static_config field is deprecated, please use `private_network_id` or `ipam_ids` instead""")
     def static_config(self) -> Optional[builtins.str]:
         """
-        Please use `ipam_ids`. Define a local ip address of your choice for the load balancer instance.
+        Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
         """
         return pulumi.get(self, "static_config")
 
@@ -1848,7 +1848,9 @@ 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,
@@ -1860,7 +1862,9 @@ class GetFrontendsFrontendResult(dict):
         :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.
                > **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`
@@ -1868,11 +1872,13 @@ class GetFrontendsFrontendResult(dict):
         :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 aont which the frontend was last updated (RFC 3339 format).
+        :param builtins.str update_at: The date on which the frontend was last updated (RFC 3339 format).
         """
         pulumi.set(__self__, "backend_id", backend_id)
         pulumi.set(__self__, "certificate_ids", certificate_ids)
+        pulumi.set(__self__, "connection_rate_limit", connection_rate_limit)
         pulumi.set(__self__, "created_at", created_at)
+        pulumi.set(__self__, "enable_access_logs", enable_access_logs)
         pulumi.set(__self__, "enable_http3", enable_http3)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "inbound_port", inbound_port)
@@ -1898,6 +1904,14 @@ class GetFrontendsFrontendResult(dict):
         """
         return pulumi.get(self, "certificate_ids")
 
+    @property
+    @pulumi.getter(name="connectionRateLimit")
+    def connection_rate_limit(self) -> builtins.int:
+        """
+        The rate limit for new connections established on this frontend. Use 0 value to disable, else value is connections per second.
+        """
+        return pulumi.get(self, "connection_rate_limit")
+
     @property
     @pulumi.getter(name="createdAt")
     def created_at(self) -> builtins.str:
@@ -1906,6 +1920,14 @@ class GetFrontendsFrontendResult(dict):
         """
         return pulumi.get(self, "created_at")
 
+    @property
+    @pulumi.getter(name="enableAccessLogs")
+    def enable_access_logs(self) -> builtins.bool:
+        """
+        Defines whether to enable access logs on the frontend.
+        """
+        return pulumi.get(self, "enable_access_logs")
+
     @property
     @pulumi.getter(name="enableHttp3")
     def enable_http3(self) -> builtins.bool:
@@ -1959,7 +1981,7 @@ class GetFrontendsFrontendResult(dict):
     @pulumi.getter(name="updateAt")
     def update_at(self) -> builtins.str:
         """
-        The date aont which the frontend was last updated (RFC 3339 format).
+        The date on which the frontend was last updated (RFC 3339 format).
         """
         return pulumi.get(self, "update_at")
 

pulumiverse_scaleway/mongo_db_instance.py

@@ -299,6 +299,7 @@ class _MongoDbInstanceState:
                  settings: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
                  snapshot_id: Optional[pulumi.Input[builtins.str]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 tls_certificate: Optional[pulumi.Input[builtins.str]] = None,
                  updated_at: Optional[pulumi.Input[builtins.str]] = None,
                  user_name: Optional[pulumi.Input[builtins.str]] = None,
                  version: Optional[pulumi.Input[builtins.str]] = None,
@@ -320,6 +321,7 @@ class _MongoDbInstanceState:
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] settings: Map of settings to define for the instance.
         :param pulumi.Input[builtins.str] snapshot_id: Snapshot ID to restore the MongoDB® instance from.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] tags: List of tags attached to the MongoDB® instance.
+        :param pulumi.Input[builtins.str] tls_certificate: The PEM-encoded TLS certificate for the MongoDB® instance, if available.
         :param pulumi.Input[builtins.str] updated_at: The date and time of the last update of the MongoDB® instance.
         :param pulumi.Input[builtins.str] user_name: Name of the user created when the intance is created.
         :param pulumi.Input[builtins.str] version: MongoDB® version of the instance.
@@ -352,6 +354,8 @@ class _MongoDbInstanceState:
             pulumi.set(__self__, "snapshot_id", snapshot_id)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
+        if tls_certificate is not None:
+            pulumi.set(__self__, "tls_certificate", tls_certificate)
         if updated_at is not None:
             pulumi.set(__self__, "updated_at", updated_at)
         if user_name is not None:
@@ -520,6 +524,18 @@ class _MongoDbInstanceState:
     def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
         pulumi.set(self, "tags", value)
 
+    @property
+    @pulumi.getter(name="tlsCertificate")
+    def tls_certificate(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The PEM-encoded TLS certificate for the MongoDB® instance, if available.
+        """
+        return pulumi.get(self, "tls_certificate")
+
+    @tls_certificate.setter
+    def tls_certificate(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "tls_certificate", value)
+
     @property
     @pulumi.getter(name="updatedAt")
     def updated_at(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -877,6 +893,7 @@ class MongoDbInstance(pulumi.CustomResource):
             __props__.__dict__["volume_size_in_gb"] = volume_size_in_gb
             __props__.__dict__["volume_type"] = volume_type
             __props__.__dict__["created_at"] = None
+            __props__.__dict__["tls_certificate"] = None
             __props__.__dict__["updated_at"] = None
         secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password"])
         opts = pulumi.ResourceOptions.merge(opts, secret_opts)
@@ -903,6 +920,7 @@ class MongoDbInstance(pulumi.CustomResource):
             settings: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
             snapshot_id: Optional[pulumi.Input[builtins.str]] = None,
             tags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+            tls_certificate: Optional[pulumi.Input[builtins.str]] = None,
             updated_at: Optional[pulumi.Input[builtins.str]] = None,
             user_name: Optional[pulumi.Input[builtins.str]] = None,
             version: Optional[pulumi.Input[builtins.str]] = None,
@@ -929,6 +947,7 @@ class MongoDbInstance(pulumi.CustomResource):
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] settings: Map of settings to define for the instance.
         :param pulumi.Input[builtins.str] snapshot_id: Snapshot ID to restore the MongoDB® instance from.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] tags: List of tags attached to the MongoDB® instance.
+        :param pulumi.Input[builtins.str] tls_certificate: The PEM-encoded TLS certificate for the MongoDB® instance, if available.
         :param pulumi.Input[builtins.str] updated_at: The date and time of the last update of the MongoDB® instance.
         :param pulumi.Input[builtins.str] user_name: Name of the user created when the intance is created.
         :param pulumi.Input[builtins.str] version: MongoDB® version of the instance.
@@ -952,6 +971,7 @@ class MongoDbInstance(pulumi.CustomResource):
         __props__.__dict__["settings"] = settings
         __props__.__dict__["snapshot_id"] = snapshot_id
         __props__.__dict__["tags"] = tags
+        __props__.__dict__["tls_certificate"] = tls_certificate
         __props__.__dict__["updated_at"] = updated_at
         __props__.__dict__["user_name"] = user_name
         __props__.__dict__["version"] = version
@@ -1064,6 +1084,14 @@ class MongoDbInstance(pulumi.CustomResource):
         """
         return pulumi.get(self, "tags")
 
+    @property
+    @pulumi.getter(name="tlsCertificate")
+    def tls_certificate(self) -> pulumi.Output[builtins.str]:
+        """
+        The PEM-encoded TLS certificate for the MongoDB® instance, if available.
+        """
+        return pulumi.get(self, "tls_certificate")
+
     @property
     @pulumi.getter(name="updatedAt")
     def updated_at(self) -> pulumi.Output[builtins.str]:

pulumiverse_scaleway/mongodb/get_instance.py

@@ -28,7 +28,7 @@ class GetInstanceResult:
     """
     A collection of values returned by getInstance.
     """
-    def __init__(__self__, created_at=None, id=None, instance_id=None, name=None, node_number=None, node_type=None, password=None, private_ips=None, private_networks=None, project_id=None, public_networks=None, region=None, settings=None, snapshot_id=None, tags=None, updated_at=None, user_name=None, version=None, volume_size_in_gb=None, volume_type=None):
+    def __init__(__self__, created_at=None, id=None, instance_id=None, name=None, node_number=None, node_type=None, password=None, private_ips=None, private_networks=None, project_id=None, public_networks=None, region=None, settings=None, snapshot_id=None, tags=None, tls_certificate=None, updated_at=None, user_name=None, version=None, volume_size_in_gb=None, volume_type=None):
         if created_at and not isinstance(created_at, str):
             raise TypeError("Expected argument 'created_at' to be a str")
         pulumi.set(__self__, "created_at", created_at)
@@ -74,6 +74,9 @@ class GetInstanceResult:
         if tags and not isinstance(tags, list):
             raise TypeError("Expected argument 'tags' to be a list")
         pulumi.set(__self__, "tags", tags)
+        if tls_certificate and not isinstance(tls_certificate, str):
+            raise TypeError("Expected argument 'tls_certificate' to be a str")
+        pulumi.set(__self__, "tls_certificate", tls_certificate)
         if updated_at and not isinstance(updated_at, str):
             raise TypeError("Expected argument 'updated_at' to be a str")
         pulumi.set(__self__, "updated_at", updated_at)
@@ -189,6 +192,11 @@ class GetInstanceResult:
         """
         return pulumi.get(self, "tags")
 
+    @property
+    @pulumi.getter(name="tlsCertificate")
+    def tls_certificate(self) -> builtins.str:
+        return pulumi.get(self, "tls_certificate")
+
     @property
     @pulumi.getter(name="updatedAt")
     def updated_at(self) -> builtins.str:
@@ -245,6 +253,7 @@ class AwaitableGetInstanceResult(GetInstanceResult):
             settings=self.settings,
             snapshot_id=self.snapshot_id,
             tags=self.tags,
+            tls_certificate=self.tls_certificate,
             updated_at=self.updated_at,
             user_name=self.user_name,
             version=self.version,
@@ -294,6 +303,7 @@ def get_instance(instance_id: Optional[builtins.str] = None,
         settings=pulumi.get(__ret__, 'settings'),
         snapshot_id=pulumi.get(__ret__, 'snapshot_id'),
         tags=pulumi.get(__ret__, 'tags'),
+        tls_certificate=pulumi.get(__ret__, 'tls_certificate'),
         updated_at=pulumi.get(__ret__, 'updated_at'),
         user_name=pulumi.get(__ret__, 'user_name'),
         version=pulumi.get(__ret__, 'version'),
@@ -340,6 +350,7 @@ def get_instance_output(instance_id: Optional[pulumi.Input[Optional[builtins.str
         settings=pulumi.get(__response__, 'settings'),
         snapshot_id=pulumi.get(__response__, 'snapshot_id'),
         tags=pulumi.get(__response__, 'tags'),
+        tls_certificate=pulumi.get(__response__, 'tls_certificate'),
         updated_at=pulumi.get(__response__, 'updated_at'),
         user_name=pulumi.get(__response__, 'user_name'),
         version=pulumi.get(__response__, 'version'),