pulumi-hcloud 1.18.0a1709364097__py3-none-any.whl → 1.22.0a1736833581__py3-none-any.whl

pulumi_hcloud/__init__.py

@@ -21,6 +21,8 @@ from .get_floating_ips import *
 from .get_image import *
 from .get_images import *
 from .get_load_balancer import *
+from .get_load_balancer_type import *
+from .get_load_balancer_types import *
 from .get_load_balancers import *
 from .get_location import *
 from .get_locations import *

pulumi_hcloud/_inputs.py

@@ -4,25 +4,58 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
     'FirewallApplyToArgs',
+    'FirewallApplyToArgsDict',
     'FirewallRuleArgs',
+    'FirewallRuleArgsDict',
     'LoadBalancerAlgorithmArgs',
+    'LoadBalancerAlgorithmArgsDict',
     'LoadBalancerServiceHealthCheckArgs',
+    'LoadBalancerServiceHealthCheckArgsDict',
     'LoadBalancerServiceHealthCheckHttpArgs',
+    'LoadBalancerServiceHealthCheckHttpArgsDict',
     'LoadBalancerServiceHttpArgs',
+    'LoadBalancerServiceHttpArgsDict',
     'LoadBalancerTargetArgs',
+    'LoadBalancerTargetArgsDict',
     'ServerNetworkArgs',
+    'ServerNetworkArgsDict',
     'ServerPublicNetArgs',
+    'ServerPublicNetArgsDict',
     'GetFirewallApplyToArgs',
+    'GetFirewallApplyToArgsDict',
     'GetFirewallRuleArgs',
+    'GetFirewallRuleArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class FirewallApplyToArgsDict(TypedDict):
+        label_selector: NotRequired[pulumi.Input[str]]
+        """
+        Label Selector to select servers the firewall should be applied to (only one
+        of `server` and `label_selector`can be applied in one block)
+        """
+        server: NotRequired[pulumi.Input[int]]
+        """
+        ID of the server you want to apply the firewall to (only one of `server`
+        and `label_selector`can be applied in one block)
+        """
+elif False:
+    FirewallApplyToArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FirewallApplyToArgs:
     def __init__(__self__, *,
@@ -66,6 +99,38 @@ class FirewallApplyToArgs:
         pulumi.set(self, "server", value)
 
 
+if not MYPY:
+    class FirewallRuleArgsDict(TypedDict):
+        direction: pulumi.Input[str]
+        """
+        Direction of the Firewall Rule. `in`
+        """
+        protocol: pulumi.Input[str]
+        """
+        Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        Description of the firewall rule
+        """
+        destination_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
+        is `out`)
+        """
+        port: NotRequired[pulumi.Input[str]]
+        """
+        Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
+        to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
+        """
+        source_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
+        is `in`)
+        """
+elif False:
+    FirewallRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class FirewallRuleArgs:
     def __init__(__self__, *,
@@ -79,12 +144,12 @@ class FirewallRuleArgs:
         :param pulumi.Input[str] direction: Direction of the Firewall Rule. `in`
         :param pulumi.Input[str] protocol: Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
         :param pulumi.Input[str] description: Description of the firewall rule
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction`
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] destination_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
                is `out`)
         :param pulumi.Input[str] port: Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
-               to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and
-               85.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ips: List of CIDRs that are allowed within this Firewall Rule
+               to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
+               is `in`)
         """
         pulumi.set(__self__, "direction", direction)
         pulumi.set(__self__, "protocol", protocol)
@@ -137,7 +202,7 @@ class FirewallRuleArgs:
     @pulumi.getter(name="destinationIps")
     def destination_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction`
+        List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
         is `out`)
         """
         return pulumi.get(self, "destination_ips")
@@ -151,8 +216,7 @@ class FirewallRuleArgs:
     def port(self) -> Optional[pulumi.Input[str]]:
         """
         Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
-        to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and
-        85.
+        to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
         """
         return pulumi.get(self, "port")
 
@@ -164,7 +228,8 @@ class FirewallRuleArgs:
     @pulumi.getter(name="sourceIps")
     def source_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        List of CIDRs that are allowed within this Firewall Rule
+        List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
+        is `in`)
         """
         return pulumi.get(self, "source_ips")
 
@@ -173,6 +238,15 @@ class FirewallRuleArgs:
         pulumi.set(self, "source_ips", value)
 
 
+if not MYPY:
+    class LoadBalancerAlgorithmArgsDict(TypedDict):
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
+        """
+elif False:
+    LoadBalancerAlgorithmArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class LoadBalancerAlgorithmArgs:
     def __init__(__self__, *,
@@ -196,6 +270,35 @@ class LoadBalancerAlgorithmArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class LoadBalancerServiceHealthCheckArgsDict(TypedDict):
+        interval: pulumi.Input[int]
+        """
+        Interval how often the health check will be performed, in seconds.
+        """
+        port: pulumi.Input[int]
+        """
+        Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
+        """
+        protocol: pulumi.Input[str]
+        """
+        Protocol the health check uses. `http` or `tcp`
+        """
+        timeout: pulumi.Input[int]
+        """
+        Timeout when a health check try will be canceled if there is no response, in seconds.
+        """
+        http: NotRequired[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgsDict']]
+        """
+        HTTP configuration. Required if `protocol` is `http`.
+        """
+        retries: NotRequired[pulumi.Input[int]]
+        """
+        Number of tries a health check will be performed until a target will be listed as `unhealthy`.
+        """
+elif False:
+    LoadBalancerServiceHealthCheckArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class LoadBalancerServiceHealthCheckArgs:
     def __init__(__self__, *,
@@ -295,6 +398,31 @@ class LoadBalancerServiceHealthCheckArgs:
         pulumi.set(self, "retries", value)
 
 
+if not MYPY:
+    class LoadBalancerServiceHealthCheckHttpArgsDict(TypedDict):
+        domain: NotRequired[pulumi.Input[str]]
+        """
+        Domain we try to access when performing the Health Check.
+        """
+        path: NotRequired[pulumi.Input[str]]
+        """
+        Path we try to access when performing the Health Check.
+        """
+        response: NotRequired[pulumi.Input[str]]
+        """
+        Response we expect to be included in the Target response when a Health Check was performed.
+        """
+        status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
+        """
+        tls: NotRequired[pulumi.Input[bool]]
+        """
+        Enable TLS certificate checking.
+        """
+elif False:
+    LoadBalancerServiceHealthCheckHttpArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class LoadBalancerServiceHealthCheckHttpArgs:
     def __init__(__self__, *,
@@ -382,6 +510,31 @@ class LoadBalancerServiceHealthCheckHttpArgs:
         pulumi.set(self, "tls", value)
 
 
+if not MYPY:
+    class LoadBalancerServiceHttpArgsDict(TypedDict):
+        certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
+        """
+        List of IDs from certificates which the Load Balancer has.
+        """
+        cookie_lifetime: NotRequired[pulumi.Input[int]]
+        """
+        Lifetime of the cookie for sticky session (in seconds). Default: `300`
+        """
+        cookie_name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the cookie for sticky session. Default: `HCLBSTICKY`
+        """
+        redirect_http: NotRequired[pulumi.Input[bool]]
+        """
+        Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
+        """
+        sticky_sessions: NotRequired[pulumi.Input[bool]]
+        """
+        Enable sticky sessions
+        """
+elif False:
+    LoadBalancerServiceHttpArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class LoadBalancerServiceHttpArgs:
     def __init__(__self__, *,
@@ -469,6 +622,17 @@ class LoadBalancerServiceHttpArgs:
         pulumi.set(self, "sticky_sessions", value)
 
 
+if not MYPY:
+    class LoadBalancerTargetArgsDict(TypedDict):
+        type: pulumi.Input[str]
+        """
+        (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
+        """
+        server_id: NotRequired[pulumi.Input[int]]
+        use_private_ip: NotRequired[pulumi.Input[bool]]
+elif False:
+    LoadBalancerTargetArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class LoadBalancerTargetArgs:
     def __init__(__self__, *,
@@ -476,14 +640,14 @@ class LoadBalancerTargetArgs:
                  server_id: Optional[pulumi.Input[int]] = None,
                  use_private_ip: Optional[pulumi.Input[bool]] = None):
         """
-        :param pulumi.Input[str] type: Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
+        :param pulumi.Input[str] type: (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
         """
         pulumi.set(__self__, "type", type)
         if server_id is not None:
             pulumi.set(__self__, "server_id", server_id)
         if use_private_ip is not None:
-            warnings.warn("""Does not work. Use the hcloud_load_balancer_target resource instead.""", DeprecationWarning)
-            pulumi.log.warn("""use_private_ip is deprecated: Does not work. Use the hcloud_load_balancer_target resource instead.""")
+            warnings.warn("""Does not work. Use the LoadBalancerTarget resource instead.""", DeprecationWarning)
+            pulumi.log.warn("""use_private_ip is deprecated: Does not work. Use the LoadBalancerTarget resource instead.""")
         if use_private_ip is not None:
             pulumi.set(__self__, "use_private_ip", use_private_ip)
 
@@ -491,7 +655,7 @@ class LoadBalancerTargetArgs:
     @pulumi.getter
     def type(self) -> pulumi.Input[str]:
         """
-        Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
+        (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
         """
         return pulumi.get(self, "type")
 
@@ -510,10 +674,8 @@ class LoadBalancerTargetArgs:
 
     @property
     @pulumi.getter(name="usePrivateIp")
+    @_utilities.deprecated("""Does not work. Use the LoadBalancerTarget resource instead.""")
     def use_private_ip(self) -> Optional[pulumi.Input[bool]]:
-        warnings.warn("""Does not work. Use the hcloud_load_balancer_target resource instead.""", DeprecationWarning)
-        pulumi.log.warn("""use_private_ip is deprecated: Does not work. Use the hcloud_load_balancer_target resource instead.""")
-
         return pulumi.get(self, "use_private_ip")
 
     @use_private_ip.setter
@@ -521,6 +683,24 @@ class LoadBalancerTargetArgs:
         pulumi.set(self, "use_private_ip", value)
 
 
+if not MYPY:
+    class ServerNetworkArgsDict(TypedDict):
+        network_id: pulumi.Input[int]
+        """
+        ID of the network
+        """
+        alias_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        ip: NotRequired[pulumi.Input[str]]
+        """
+        Specify the IP the server should get in the network
+        """
+        mac_address: NotRequired[pulumi.Input[str]]
+        """
+        (Optional, string) The MAC address the private interface of the server has
+        """
+elif False:
+    ServerNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ServerNetworkArgs:
     def __init__(__self__, *,
@@ -587,6 +767,15 @@ class ServerNetworkArgs:
         pulumi.set(self, "mac_address", value)
 
 
+if not MYPY:
+    class ServerPublicNetArgsDict(TypedDict):
+        ipv4: NotRequired[pulumi.Input[int]]
+        ipv4_enabled: NotRequired[pulumi.Input[bool]]
+        ipv6: NotRequired[pulumi.Input[int]]
+        ipv6_enabled: NotRequired[pulumi.Input[bool]]
+elif False:
+    ServerPublicNetArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ServerPublicNetArgs:
     def __init__(__self__, *,
@@ -640,6 +829,20 @@ class ServerPublicNetArgs:
         pulumi.set(self, "ipv6_enabled", value)
 
 
+if not MYPY:
+    class GetFirewallApplyToArgsDict(TypedDict):
+        label_selector: str
+        """
+        (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
+        referenced
+        """
+        server: int
+        """
+        (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
+        """
+elif False:
+    GetFirewallApplyToArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetFirewallApplyToArgs:
     def __init__(__self__, *,
@@ -679,6 +882,35 @@ class GetFirewallApplyToArgs:
         pulumi.set(self, "server", value)
 
 
+if not MYPY:
+    class GetFirewallRuleArgsDict(TypedDict):
+        direction: str
+        """
+        (Required, string) Direction of the Firewall Rule. `in`, `out`
+        """
+        description: NotRequired[str]
+        """
+        (Optional, string) Description of the firewall rule
+        """
+        destination_ips: NotRequired[Sequence[str]]
+        """
+        (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
+        """
+        port: NotRequired[str]
+        """
+        (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
+        """
+        protocol: NotRequired[str]
+        """
+        (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
+        """
+        source_ips: NotRequired[Sequence[str]]
+        """
+        (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
+        """
+elif False:
+    GetFirewallRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetFirewallRuleArgs:
     def __init__(__self__, *,

pulumi_hcloud/_utilities.py

@@ -4,6 +4,7 @@
 
 
 import asyncio
+import functools
 import importlib.metadata
 import importlib.util
 import inspect
@@ -11,14 +12,19 @@ import json
 import os
 import sys
 import typing
+import warnings
+import base64
 
 import pulumi
 import pulumi.runtime
 from pulumi.runtime.sync_await import _sync_await
+from pulumi.runtime.proto import resource_pb2
 
 from semver import VersionInfo as SemverVersion
 from parver import Version as PEP440Version
 
+C = typing.TypeVar("C", bound=typing.Callable)
+
 
 def get_env(*args):
     for v in args:
@@ -96,10 +102,6 @@ def _get_semver_version():
 _version = _get_semver_version()
 _version_str = str(_version)
 
-
-def get_version():
-    return _version_str
-
 def get_resource_opts_defaults() -> pulumi.ResourceOptions:
     return pulumi.ResourceOptions(
         version=get_version(),
@@ -262,7 +264,7 @@ def call_plain(
     output = pulumi.runtime.call(tok, props, res, typ)
 
     # Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency.
-    result, known, secret, _ = _sync_await(asyncio.ensure_future(_await_output(output)))
+    result, known, secret, _ = _sync_await(asyncio.create_task(_await_output(output)))
 
     problem = None
     if not known:
@@ -287,5 +289,39 @@ async def _await_output(o: pulumi.Output[typing.Any]) -> typing.Tuple[object, bo
         await o._resources,
     )
 
+
+# This is included to provide an upgrade path for users who are using a version
+# of the Pulumi SDK (<3.121.0) that does not include the `deprecated` decorator.
+def deprecated(message: str) -> typing.Callable[[C], C]:
+    """
+    Decorator to indicate a function is deprecated.
+
+    As well as inserting appropriate statements to indicate that the function is
+    deprecated, this decorator also tags the function with a special attribute
+    so that Pulumi code can detect that it is deprecated and react appropriately
+    in certain situations.
+
+    message is the deprecation message that should be printed if the function is called.
+    """
+
+    def decorator(fn: C) -> C:
+        if not callable(fn):
+            raise TypeError("Expected fn to be callable")
+
+        @functools.wraps(fn)
+        def deprecated_fn(*args, **kwargs):
+            warnings.warn(message)
+            pulumi.warn(f"{fn.__name__} is deprecated: {message}")
+
+            return fn(*args, **kwargs)
+
+        deprecated_fn.__dict__["_pulumi_deprecated_callable"] = fn
+        return typing.cast(C, deprecated_fn)
+
+    return decorator
+
 def get_plugin_download_url():
 	return None
+
+def get_version():
+     return _version_str

pulumi_hcloud/certificate.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = ['CertificateArgs', 'Certificate']
@@ -16,7 +21,7 @@ class CertificateArgs:
     def __init__(__self__, *,
                  certificate: pulumi.Input[str],
                  private_key: pulumi.Input[str],
-                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a Certificate resource.
@@ -48,11 +53,11 @@ class CertificateArgs:
 
     @property
     @pulumi.getter
-    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         return pulumi.get(self, "labels")
 
     @labels.setter
-    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "labels", value)
 
     @property
@@ -72,7 +77,7 @@ class _CertificateState:
                  created: Optional[pulumi.Input[str]] = None,
                  domain_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  fingerprint: Optional[pulumi.Input[str]] = None,
-                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  not_valid_after: Optional[pulumi.Input[str]] = None,
                  not_valid_before: Optional[pulumi.Input[str]] = None,
@@ -140,11 +145,11 @@ class _CertificateState:
 
     @property
     @pulumi.getter
-    def labels(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         return pulumi.get(self, "labels")
 
     @labels.setter
-    def labels(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "labels", value)
 
     @property
@@ -199,7 +204,7 @@ class Certificate(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  certificate: Optional[pulumi.Input[str]] = None,
-                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  private_key: Optional[pulumi.Input[str]] = None,
                  __props__=None):
@@ -236,7 +241,7 @@ class Certificate(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  certificate: Optional[pulumi.Input[str]] = None,
-                 labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+                 labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  private_key: Optional[pulumi.Input[str]] = None,
                  __props__=None):
@@ -278,7 +283,7 @@ class Certificate(pulumi.CustomResource):
             created: Optional[pulumi.Input[str]] = None,
             domain_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             fingerprint: Optional[pulumi.Input[str]] = None,
-            labels: Optional[pulumi.Input[Mapping[str, Any]]] = None,
+            labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             name: Optional[pulumi.Input[str]] = None,
             not_valid_after: Optional[pulumi.Input[str]] = None,
             not_valid_before: Optional[pulumi.Input[str]] = None,
@@ -330,7 +335,7 @@ class Certificate(pulumi.CustomResource):
 
     @property
     @pulumi.getter
-    def labels(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:
+    def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
         return pulumi.get(self, "labels")
 
     @property

pulumi_hcloud/config/__init__.pyi

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 endpoint: Optional[str]

pulumi_hcloud/config/vars.py

@@ -4,9 +4,14 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 import types