pulumiverse-scaleway 1.26.0a1742897201__py3-none-any.whl → 1.27.0__py3-none-any.whl

pulumiverse_scaleway/outputs.py

@@ -43,6 +43,14 @@ __all__ = [
     'DomainRecordHttpService',
     'DomainRecordView',
     'DomainRecordWeighted',
+    'EdgeServicesBackendStageLbBackendConfig',
+    'EdgeServicesBackendStageLbBackendConfigLbConfig',
+    'EdgeServicesBackendStageS3BackendConfig',
+    'EdgeServicesCacheStagePurgeRequest',
+    'EdgeServicesRouteStageRule',
+    'EdgeServicesRouteStageRuleRuleHttpMatch',
+    'EdgeServicesRouteStageRuleRuleHttpMatchPathFilter',
+    'EdgeServicesTlsStageSecret',
     'FunctionTriggerNats',
     'FunctionTriggerSqs',
     'IamPolicyRule',
@@ -69,6 +77,7 @@ __all__ = [
     'IpamIpReverse',
     'IpamIpSource',
     'JobDefinitionCron',
+    'JobDefinitionSecretReference',
     'KubernetesClusterAutoUpgrade',
     'KubernetesClusterAutoscalerConfig',
     'KubernetesClusterKubeconfig',
@@ -109,6 +118,7 @@ __all__ = [
     'RedisClusterPrivateNetwork',
     'RedisClusterPublicNetwork',
     'SecretEphemeralPolicy',
+    'SecretVersion',
     'TemDomainReputation',
     'VpcGatewayNetworkIpamConfig',
     'VpcPrivateNetworkIpv4Subnet',
@@ -199,6 +209,7 @@ __all__ = [
     'GetRedisClusterPrivateNetworkResult',
     'GetRedisClusterPublicNetworkResult',
     'GetSecretEphemeralPolicyResult',
+    'GetSecretVersionResult',
     'GetTemDomainReputationResult',
     'GetVpcGatewayNetworkIpamConfigResult',
     'GetVpcPrivateNetworkIpv4SubnetResult',
@@ -2000,6 +2011,447 @@ class DomainRecordWeighted(dict):
         return pulumi.get(self, "weight")
 
 
+@pulumi.output_type
+class EdgeServicesBackendStageLbBackendConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lbConfig":
+            suggest = "lb_config"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesBackendStageLbBackendConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesBackendStageLbBackendConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesBackendStageLbBackendConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 lb_config: Optional['outputs.EdgeServicesBackendStageLbBackendConfigLbConfig'] = None):
+        """
+        :param 'EdgeServicesBackendStageLbBackendConfigLbConfigArgs' lb_config: The Load Balancer config.
+        """
+        if lb_config is not None:
+            pulumi.set(__self__, "lb_config", lb_config)
+
+    @property
+    @pulumi.getter(name="lbConfig")
+    def lb_config(self) -> Optional['outputs.EdgeServicesBackendStageLbBackendConfigLbConfig']:
+        """
+        The Load Balancer config.
+        """
+        return pulumi.get(self, "lb_config")
+
+
+@pulumi.output_type
+class EdgeServicesBackendStageLbBackendConfigLbConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "domainName":
+            suggest = "domain_name"
+        elif key == "frontendId":
+            suggest = "frontend_id"
+        elif key == "isSsl":
+            suggest = "is_ssl"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesBackendStageLbBackendConfigLbConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesBackendStageLbBackendConfigLbConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesBackendStageLbBackendConfigLbConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 domain_name: Optional[str] = None,
+                 frontend_id: Optional[str] = None,
+                 id: Optional[str] = None,
+                 is_ssl: Optional[bool] = None,
+                 zone: Optional[str] = None):
+        """
+        :param str domain_name: The Fully Qualified Domain Name (in the format subdomain.example.com) to use in HTTP requests sent towards your Load Balancer.
+        :param str frontend_id: The ID of the frontend.
+        :param str id: The ID of the Load Balancer.
+        :param bool is_ssl: Defines whether the Load Balancer's frontend handles SSL connections.
+        :param str zone: `zone`) The zone of the Load Balancer.
+        """
+        if domain_name is not None:
+            pulumi.set(__self__, "domain_name", domain_name)
+        if frontend_id is not None:
+            pulumi.set(__self__, "frontend_id", frontend_id)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if is_ssl is not None:
+            pulumi.set(__self__, "is_ssl", is_ssl)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
+
+    @property
+    @pulumi.getter(name="domainName")
+    def domain_name(self) -> Optional[str]:
+        """
+        The Fully Qualified Domain Name (in the format subdomain.example.com) to use in HTTP requests sent towards your Load Balancer.
+        """
+        return pulumi.get(self, "domain_name")
+
+    @property
+    @pulumi.getter(name="frontendId")
+    def frontend_id(self) -> Optional[str]:
+        """
+        The ID of the frontend.
+        """
+        return pulumi.get(self, "frontend_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        The ID of the Load Balancer.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="isSsl")
+    def is_ssl(self) -> Optional[bool]:
+        """
+        Defines whether the Load Balancer's frontend handles SSL connections.
+        """
+        return pulumi.get(self, "is_ssl")
+
+    @property
+    @pulumi.getter
+    def zone(self) -> Optional[str]:
+        """
+        `zone`) The zone of the Load Balancer.
+        """
+        return pulumi.get(self, "zone")
+
+
+@pulumi.output_type
+class EdgeServicesBackendStageS3BackendConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bucketName":
+            suggest = "bucket_name"
+        elif key == "bucketRegion":
+            suggest = "bucket_region"
+        elif key == "isWebsite":
+            suggest = "is_website"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesBackendStageS3BackendConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesBackendStageS3BackendConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesBackendStageS3BackendConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bucket_name: Optional[str] = None,
+                 bucket_region: Optional[str] = None,
+                 is_website: Optional[bool] = None):
+        """
+        :param str bucket_name: The name of the Bucket.
+        :param str bucket_region: The region of the Bucket.
+        :param bool is_website: Defines whether the bucket website feature is enabled.
+        """
+        if bucket_name is not None:
+            pulumi.set(__self__, "bucket_name", bucket_name)
+        if bucket_region is not None:
+            pulumi.set(__self__, "bucket_region", bucket_region)
+        if is_website is not None:
+            pulumi.set(__self__, "is_website", is_website)
+
+    @property
+    @pulumi.getter(name="bucketName")
+    def bucket_name(self) -> Optional[str]:
+        """
+        The name of the Bucket.
+        """
+        return pulumi.get(self, "bucket_name")
+
+    @property
+    @pulumi.getter(name="bucketRegion")
+    def bucket_region(self) -> Optional[str]:
+        """
+        The region of the Bucket.
+        """
+        return pulumi.get(self, "bucket_region")
+
+    @property
+    @pulumi.getter(name="isWebsite")
+    def is_website(self) -> Optional[bool]:
+        """
+        Defines whether the bucket website feature is enabled.
+        """
+        return pulumi.get(self, "is_website")
+
+
+@pulumi.output_type
+class EdgeServicesCacheStagePurgeRequest(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "pipelineId":
+            suggest = "pipeline_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesCacheStagePurgeRequest. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesCacheStagePurgeRequest.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesCacheStagePurgeRequest.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 all: Optional[bool] = None,
+                 assets: Optional[Sequence[str]] = None,
+                 pipeline_id: Optional[str] = None):
+        """
+        :param bool all: Defines whether to purge all content.
+        :param Sequence[str] assets: The list of asserts to purge.
+        :param str pipeline_id: The pipeline ID in which the purge request will be created.
+        """
+        if all is not None:
+            pulumi.set(__self__, "all", all)
+        if assets is not None:
+            pulumi.set(__self__, "assets", assets)
+        if pipeline_id is not None:
+            pulumi.set(__self__, "pipeline_id", pipeline_id)
+
+    @property
+    @pulumi.getter
+    def all(self) -> Optional[bool]:
+        """
+        Defines whether to purge all content.
+        """
+        return pulumi.get(self, "all")
+
+    @property
+    @pulumi.getter
+    def assets(self) -> Optional[Sequence[str]]:
+        """
+        The list of asserts to purge.
+        """
+        return pulumi.get(self, "assets")
+
+    @property
+    @pulumi.getter(name="pipelineId")
+    def pipeline_id(self) -> Optional[str]:
+        """
+        The pipeline ID in which the purge request will be created.
+        """
+        return pulumi.get(self, "pipeline_id")
+
+
+@pulumi.output_type
+class EdgeServicesRouteStageRule(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backendStageId":
+            suggest = "backend_stage_id"
+        elif key == "ruleHttpMatch":
+            suggest = "rule_http_match"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesRouteStageRule. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesRouteStageRule.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesRouteStageRule.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 backend_stage_id: str,
+                 rule_http_match: Optional['outputs.EdgeServicesRouteStageRuleRuleHttpMatch'] = None):
+        """
+        :param str backend_stage_id: The ID of the backend stage that requests matching the rule should be forwarded to.
+        :param 'EdgeServicesRouteStageRuleRuleHttpMatchArgs' rule_http_match: The rule condition to be matched. Requests matching the condition defined here will be directly forwarded to the backend specified by the `backend_stage_id` field. Requests that do not match will be checked by the next rule's condition.
+        """
+        pulumi.set(__self__, "backend_stage_id", backend_stage_id)
+        if rule_http_match is not None:
+            pulumi.set(__self__, "rule_http_match", rule_http_match)
+
+    @property
+    @pulumi.getter(name="backendStageId")
+    def backend_stage_id(self) -> str:
+        """
+        The ID of the backend stage that requests matching the rule should be forwarded to.
+        """
+        return pulumi.get(self, "backend_stage_id")
+
+    @property
+    @pulumi.getter(name="ruleHttpMatch")
+    def rule_http_match(self) -> Optional['outputs.EdgeServicesRouteStageRuleRuleHttpMatch']:
+        """
+        The rule condition to be matched. Requests matching the condition defined here will be directly forwarded to the backend specified by the `backend_stage_id` field. Requests that do not match will be checked by the next rule's condition.
+        """
+        return pulumi.get(self, "rule_http_match")
+
+
+@pulumi.output_type
+class EdgeServicesRouteStageRuleRuleHttpMatch(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "methodFilters":
+            suggest = "method_filters"
+        elif key == "pathFilter":
+            suggest = "path_filter"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesRouteStageRuleRuleHttpMatch. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesRouteStageRuleRuleHttpMatch.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesRouteStageRuleRuleHttpMatch.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 method_filters: Optional[Sequence[str]] = None,
+                 path_filter: Optional['outputs.EdgeServicesRouteStageRuleRuleHttpMatchPathFilter'] = None):
+        """
+        :param Sequence[str] method_filters: HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are `get`, `post`, `put`, `patch`, `delete`, `head`, `options`. All methods will match if none is provided.
+        :param 'EdgeServicesRouteStageRuleRuleHttpMatchPathFilterArgs' path_filter: HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
+        """
+        if method_filters is not None:
+            pulumi.set(__self__, "method_filters", method_filters)
+        if path_filter is not None:
+            pulumi.set(__self__, "path_filter", path_filter)
+
+    @property
+    @pulumi.getter(name="methodFilters")
+    def method_filters(self) -> Optional[Sequence[str]]:
+        """
+        HTTP methods to filter for. A request using any of these methods will be considered to match the rule. Possible values are `get`, `post`, `put`, `patch`, `delete`, `head`, `options`. All methods will match if none is provided.
+        """
+        return pulumi.get(self, "method_filters")
+
+    @property
+    @pulumi.getter(name="pathFilter")
+    def path_filter(self) -> Optional['outputs.EdgeServicesRouteStageRuleRuleHttpMatchPathFilter']:
+        """
+        HTTP URL path to filter for. A request whose path matches the given filter will be considered to match the rule. All paths will match if none is provided.
+        """
+        return pulumi.get(self, "path_filter")
+
+
+@pulumi.output_type
+class EdgeServicesRouteStageRuleRuleHttpMatchPathFilter(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "pathFilterType":
+            suggest = "path_filter_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesRouteStageRuleRuleHttpMatchPathFilter. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesRouteStageRuleRuleHttpMatchPathFilter.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesRouteStageRuleRuleHttpMatchPathFilter.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 path_filter_type: str,
+                 value: str):
+        """
+        :param str path_filter_type: The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the `regex` type.
+        :param str value: The value to be matched for the HTTP URL path.
+        """
+        pulumi.set(__self__, "path_filter_type", path_filter_type)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter(name="pathFilterType")
+    def path_filter_type(self) -> str:
+        """
+        The type of filter to match for the HTTP URL path. For now, all path filters must be written in regex and use the `regex` type.
+        """
+        return pulumi.get(self, "path_filter_type")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        The value to be matched for the HTTP URL path.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class EdgeServicesTlsStageSecret(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "secretId":
+            suggest = "secret_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EdgeServicesTlsStageSecret. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EdgeServicesTlsStageSecret.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EdgeServicesTlsStageSecret.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 region: Optional[str] = None,
+                 secret_id: Optional[str] = None):
+        """
+        :param str region: The region of the secret.
+        :param str secret_id: The ID of the Secret
+        """
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if secret_id is not None:
+            pulumi.set(__self__, "secret_id", secret_id)
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[str]:
+        """
+        The region of the secret.
+        """
+        return pulumi.get(self, "region")
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> Optional[str]:
+        """
+        The ID of the Secret
+        """
+        return pulumi.get(self, "secret_id")
+
+
 @pulumi.output_type
 class FunctionTriggerNats(dict):
     @staticmethod
@@ -3800,6 +4252,93 @@ class JobDefinitionCron(dict):
         return pulumi.get(self, "timezone")
 
 
+@pulumi.output_type
+class JobDefinitionSecretReference(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "secretId":
+            suggest = "secret_id"
+        elif key == "secretReferenceId":
+            suggest = "secret_reference_id"
+        elif key == "secretVersion":
+            suggest = "secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in JobDefinitionSecretReference. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        JobDefinitionSecretReference.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        JobDefinitionSecretReference.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 secret_id: str,
+                 environment: Optional[str] = None,
+                 file: Optional[str] = None,
+                 secret_reference_id: Optional[str] = None,
+                 secret_version: Optional[str] = None):
+        """
+        :param str secret_id: The secret unique identifier, it could be formatted as region/UUID or UUID. In case the region is passed, it must be the same as the job definition. You could reference the same secret multiple times in the same job definition.
+        :param str environment: An environment variable containing the secret value. Must be specified if `file` is not specified.
+        :param str file: The absolute file path where the secret will be mounted. Must be specified if `environment` is not specified.
+        :param str secret_reference_id: The secret reference UUID that is automatically generated by the provider.
+        :param str secret_version: The secret version.
+        """
+        pulumi.set(__self__, "secret_id", secret_id)
+        if environment is not None:
+            pulumi.set(__self__, "environment", environment)
+        if file is not None:
+            pulumi.set(__self__, "file", file)
+        if secret_reference_id is not None:
+            pulumi.set(__self__, "secret_reference_id", secret_reference_id)
+        if secret_version is not None:
+            pulumi.set(__self__, "secret_version", secret_version)
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> str:
+        """
+        The secret unique identifier, it could be formatted as region/UUID or UUID. In case the region is passed, it must be the same as the job definition. You could reference the same secret multiple times in the same job definition.
+        """
+        return pulumi.get(self, "secret_id")
+
+    @property
+    @pulumi.getter
+    def environment(self) -> Optional[str]:
+        """
+        An environment variable containing the secret value. Must be specified if `file` is not specified.
+        """
+        return pulumi.get(self, "environment")
+
+    @property
+    @pulumi.getter
+    def file(self) -> Optional[str]:
+        """
+        The absolute file path where the secret will be mounted. Must be specified if `environment` is not specified.
+        """
+        return pulumi.get(self, "file")
+
+    @property
+    @pulumi.getter(name="secretReferenceId")
+    def secret_reference_id(self) -> Optional[str]:
+        """
+        The secret reference UUID that is automatically generated by the provider.
+        """
+        return pulumi.get(self, "secret_reference_id")
+
+    @property
+    @pulumi.getter(name="secretVersion")
+    def secret_version(self) -> Optional[str]:
+        """
+        The secret version.
+        """
+        return pulumi.get(self, "secret_version")
+
+
 @pulumi.output_type
 class KubernetesClusterAutoUpgrade(dict):
     @staticmethod
@@ -6235,6 +6774,118 @@ class SecretEphemeralPolicy(dict):
         return pulumi.get(self, "ttl")
 
 
+@pulumi.output_type
+class SecretVersion(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createdAt":
+            suggest = "created_at"
+        elif key == "secretId":
+            suggest = "secret_id"
+        elif key == "updatedAt":
+            suggest = "updated_at"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SecretVersion. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SecretVersion.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SecretVersion.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 created_at: Optional[str] = None,
+                 description: Optional[str] = None,
+                 latest: Optional[bool] = None,
+                 revision: Optional[str] = None,
+                 secret_id: Optional[str] = None,
+                 status: Optional[str] = None,
+                 updated_at: Optional[str] = None):
+        """
+        :param str created_at: Date and time of the secret's creation (in RFC 3339 format).
+        :param str description: Description of the secret (e.g. `my-new-description`).
+        :param bool latest: Returns true if the version is the latest.
+        :param str revision: The revision of secret version
+        :param str secret_id: The secret ID associated with this version
+        :param str status: The status of the secret.
+        :param str updated_at: Date and time of the secret's last update (in RFC 3339 format).
+        """
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if latest is not None:
+            pulumi.set(__self__, "latest", latest)
+        if revision is not None:
+            pulumi.set(__self__, "revision", revision)
+        if secret_id is not None:
+            pulumi.set(__self__, "secret_id", secret_id)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if updated_at is not None:
+            pulumi.set(__self__, "updated_at", updated_at)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[str]:
+        """
+        Date and time of the secret's creation (in RFC 3339 format).
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        Description of the secret (e.g. `my-new-description`).
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def latest(self) -> Optional[bool]:
+        """
+        Returns true if the version is the latest.
+        """
+        return pulumi.get(self, "latest")
+
+    @property
+    @pulumi.getter
+    def revision(self) -> Optional[str]:
+        """
+        The revision of secret version
+        """
+        return pulumi.get(self, "revision")
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> Optional[str]:
+        """
+        The secret ID associated with this version
+        """
+        return pulumi.get(self, "secret_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The status of the secret.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> Optional[str]:
+        """
+        Date and time of the secret's last update (in RFC 3339 format).
+        """
+        return pulumi.get(self, "updated_at")
+
+
 @pulumi.output_type
 class TemDomainReputation(dict):
     @staticmethod
@@ -8643,7 +9294,6 @@ class GetInstanceServersServerResult(dict):
                  project_id: str,
                  public_ip: str,
                  public_ips: Sequence['outputs.GetInstanceServersServerPublicIpResult'],
-                 routed_ip_enabled: bool,
                  security_group_id: str,
                  state: str,
                  tags: Sequence[str],
@@ -8665,7 +9315,6 @@ class GetInstanceServersServerResult(dict):
         :param str project_id: The ID of the project the server is associated with.
         :param str public_ip: The public IP address of the server.
         :param Sequence['GetInstanceServersServerPublicIpArgs'] public_ips: The list of public IPs of the server
-        :param bool routed_ip_enabled: True if the server support routed ip only.
         :param str security_group_id: The [security group](https://developers.scaleway.com/en/products/instance/api/#security-groups-8d7f89) the server is attached to.
         :param str state: The state of the server. Possible values are: `started`, `stopped` or `standby`.
         :param Sequence[str] tags: List of tags used as filter. Servers with these exact tags are listed.
@@ -8689,7 +9338,6 @@ class GetInstanceServersServerResult(dict):
         pulumi.set(__self__, "project_id", project_id)
         pulumi.set(__self__, "public_ip", public_ip)
         pulumi.set(__self__, "public_ips", public_ips)
-        pulumi.set(__self__, "routed_ip_enabled", routed_ip_enabled)
         pulumi.set(__self__, "security_group_id", security_group_id)
         pulumi.set(__self__, "state", state)
         pulumi.set(__self__, "tags", tags)
@@ -8828,14 +9476,6 @@ class GetInstanceServersServerResult(dict):
         """
         return pulumi.get(self, "public_ips")
 
-    @property
-    @pulumi.getter(name="routedIpEnabled")
-    def routed_ip_enabled(self) -> bool:
-        """
-        True if the server support routed ip only.
-        """
-        return pulumi.get(self, "routed_ip_enabled")
-
     @property
     @pulumi.getter(name="securityGroupId")
     def security_group_id(self) -> str:
@@ -10279,7 +10919,7 @@ class GetLbBackendsBackendHealthCheckHttpResult(dict):
         :param str host_header: The HTTP host header to use for health check requests.
         :param str method: The HTTP method to use for health check requests.
         :param str sni: The SNI to use for HC requests over SSL.
-        :param str uri: The HTTPS endpoint URL to call for health check requests.
+        :param str uri: The path of health check requests.
         """
         pulumi.set(__self__, "code", code)
         pulumi.set(__self__, "host_header", host_header)
@@ -10323,7 +10963,7 @@ class GetLbBackendsBackendHealthCheckHttpResult(dict):
     @pulumi.getter
     def uri(self) -> str:
         """
-        The HTTPS endpoint URL to call for health check requests.
+        The path of health check requests.
         """
         return pulumi.get(self, "uri")
 
@@ -10765,6 +11405,7 @@ class GetLbRoutesRouteResult(dict):
                  id: str,
                  match_host_header: str,
                  match_sni: str,
+                 match_subdomains: bool,
                  update_at: str):
         """
         :param str backend_id: The backend ID to redirect to
@@ -10773,6 +11414,7 @@ class GetLbRoutesRouteResult(dict):
         :param str id: The associated route ID.
         :param str match_host_header: Specifies the host of the server to which the request is being sent.
         :param str match_sni: Server Name Indication TLS extension field from an incoming connection made via an SSL/TLS transport layer.
+        :param bool match_subdomains: If true, all subdomains will match.
         :param str update_at: The date on which the route was last updated (RFC 3339 format).
         """
         pulumi.set(__self__, "backend_id", backend_id)
@@ -10781,6 +11423,7 @@ class GetLbRoutesRouteResult(dict):
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "match_host_header", match_host_header)
         pulumi.set(__self__, "match_sni", match_sni)
+        pulumi.set(__self__, "match_subdomains", match_subdomains)
         pulumi.set(__self__, "update_at", update_at)
 
     @property
@@ -10831,6 +11474,14 @@ class GetLbRoutesRouteResult(dict):
         """
         return pulumi.get(self, "match_sni")
 
+    @property
+    @pulumi.getter(name="matchSubdomains")
+    def match_subdomains(self) -> bool:
+        """
+        If true, all subdomains will match.
+        """
+        return pulumi.get(self, "match_subdomains")
+
     @property
     @pulumi.getter(name="updateAt")
     def update_at(self) -> str:
@@ -11775,6 +12426,92 @@ class GetSecretEphemeralPolicyResult(dict):
         return pulumi.get(self, "ttl")
 
 
+@pulumi.output_type
+class GetSecretVersionResult(dict):
+    def __init__(__self__, *,
+                 created_at: str,
+                 description: str,
+                 latest: bool,
+                 revision: str,
+                 secret_id: str,
+                 status: str,
+                 updated_at: str):
+        """
+        :param str created_at: Date and time of secret version's creation (RFC 3339 format)
+        :param str description: Description of the secret version
+        :param bool latest: Returns true if the version is the latest.
+        :param str revision: The revision of secret version
+        :param str secret_id: The ID of the secret.
+               Only one of `name` and `secret_id` should be specified.
+        :param str status: Status of the secret version
+        :param str updated_at: Date and time of secret version's creation (RFC 3339 format)
+        """
+        pulumi.set(__self__, "created_at", created_at)
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "latest", latest)
+        pulumi.set(__self__, "revision", revision)
+        pulumi.set(__self__, "secret_id", secret_id)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "updated_at", updated_at)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> str:
+        """
+        Date and time of secret version's creation (RFC 3339 format)
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        Description of the secret version
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def latest(self) -> bool:
+        """
+        Returns true if the version is the latest.
+        """
+        return pulumi.get(self, "latest")
+
+    @property
+    @pulumi.getter
+    def revision(self) -> str:
+        """
+        The revision of secret version
+        """
+        return pulumi.get(self, "revision")
+
+    @property
+    @pulumi.getter(name="secretId")
+    def secret_id(self) -> str:
+        """
+        The ID of the secret.
+        Only one of `name` and `secret_id` should be specified.
+        """
+        return pulumi.get(self, "secret_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        Status of the secret version
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> str:
+        """
+        Date and time of secret version's creation (RFC 3339 format)
+        """
+        return pulumi.get(self, "updated_at")
+
+
 @pulumi.output_type
 class GetTemDomainReputationResult(dict):
     def __init__(__self__, *,