pulumi-hcloud 1.20.4__py3-none-any.whl → 1.20.5__py3-none-any.whl

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__, *,
@@ -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__, *,
@@ -519,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__, *,
@@ -585,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__, *,
@@ -638,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__, *,
@@ -677,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

@@ -264,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:

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']

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

pulumi_hcloud/firewall.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
 from . import outputs
 from ._inputs import *

pulumi_hcloud/firewall_attachment.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__ = ['FirewallAttachmentArgs', 'FirewallAttachment']

pulumi_hcloud/floating_ip.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__ = ['FloatingIpArgs', 'FloatingIp']

pulumi_hcloud/floating_ip_assignment.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__ = ['FloatingIpAssignmentArgs', 'FloatingIpAssignment']

pulumi_hcloud/get_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__ = [
@@ -197,9 +202,6 @@ def get_certificate(id: Optional[int] = None,
         not_valid_before=pulumi.get(__ret__, 'not_valid_before'),
         type=pulumi.get(__ret__, 'type'),
         with_selector=pulumi.get(__ret__, 'with_selector'))
-
-
-@_utilities.lift_output_func(get_certificate)
 def get_certificate_output(id: Optional[pulumi.Input[Optional[int]]] = None,
                            name: Optional[pulumi.Input[Optional[str]]] = None,
                            with_selector: Optional[pulumi.Input[Optional[str]]] = None,
@@ -220,4 +222,21 @@ def get_certificate_output(id: Optional[pulumi.Input[Optional[int]]] = None,
     :param str name: Name of the certificate.
     :param str with_selector: [Label selector](https://docs.hetzner.cloud/#overview-label-selector)
     """
-    ...
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['name'] = name
+    __args__['withSelector'] = with_selector
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('hcloud:index/getCertificate:getCertificate', __args__, opts=opts, typ=GetCertificateResult)
+    return __ret__.apply(lambda __response__: GetCertificateResult(
+        certificate=pulumi.get(__response__, 'certificate'),
+        created=pulumi.get(__response__, 'created'),
+        domain_names=pulumi.get(__response__, 'domain_names'),
+        fingerprint=pulumi.get(__response__, 'fingerprint'),
+        id=pulumi.get(__response__, 'id'),
+        labels=pulumi.get(__response__, 'labels'),
+        name=pulumi.get(__response__, 'name'),
+        not_valid_after=pulumi.get(__response__, 'not_valid_after'),
+        not_valid_before=pulumi.get(__response__, 'not_valid_before'),
+        type=pulumi.get(__response__, 'type'),
+        with_selector=pulumi.get(__response__, 'with_selector')))

pulumi_hcloud/get_certificates.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
 from . import outputs
 
@@ -92,9 +97,6 @@ def get_certificates(with_selector: Optional[str] = None,
         certificates=pulumi.get(__ret__, 'certificates'),
         id=pulumi.get(__ret__, 'id'),
         with_selector=pulumi.get(__ret__, 'with_selector'))
-
-
-@_utilities.lift_output_func(get_certificates)
 def get_certificates_output(with_selector: Optional[pulumi.Input[Optional[str]]] = None,
                             opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetCertificatesResult]:
     """
@@ -112,4 +114,11 @@ def get_certificates_output(with_selector: Optional[pulumi.Input[Optional[str]]]
 
     :param str with_selector: [Label selector](https://docs.hetzner.cloud/#overview-label-selector)
     """
-    ...
+    __args__ = dict()
+    __args__['withSelector'] = with_selector
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('hcloud:index/getCertificates:getCertificates', __args__, opts=opts, typ=GetCertificatesResult)
+    return __ret__.apply(lambda __response__: GetCertificatesResult(
+        certificates=pulumi.get(__response__, 'certificates'),
+        id=pulumi.get(__response__, 'id'),
+        with_selector=pulumi.get(__response__, 'with_selector')))

pulumi_hcloud/get_datacenter.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__ = [
@@ -138,9 +143,6 @@ def get_datacenter(id: Optional[int] = None,
         location=pulumi.get(__ret__, 'location'),
         name=pulumi.get(__ret__, 'name'),
         supported_server_type_ids=pulumi.get(__ret__, 'supported_server_type_ids'))
-
-
-@_utilities.lift_output_func(get_datacenter)
 def get_datacenter_output(id: Optional[pulumi.Input[Optional[int]]] = None,
                           name: Optional[pulumi.Input[Optional[str]]] = None,
                           opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDatacenterResult]:
@@ -162,4 +164,15 @@ def get_datacenter_output(id: Optional[pulumi.Input[Optional[int]]] = None,
     :param int id: ID of the datacenter.
     :param str name: Name of the datacenter.
     """
-    ...
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['name'] = name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('hcloud:index/getDatacenter:getDatacenter', __args__, opts=opts, typ=GetDatacenterResult)
+    return __ret__.apply(lambda __response__: GetDatacenterResult(
+        available_server_type_ids=pulumi.get(__response__, 'available_server_type_ids'),
+        description=pulumi.get(__response__, 'description'),
+        id=pulumi.get(__response__, 'id'),
+        location=pulumi.get(__response__, 'location'),
+        name=pulumi.get(__response__, 'name'),
+        supported_server_type_ids=pulumi.get(__response__, 'supported_server_type_ids')))

pulumi_hcloud/get_datacenters.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
 from . import outputs
 
@@ -121,9 +126,6 @@ def get_datacenters(datacenter_ids: Optional[Sequence[str]] = None,
         descriptions=pulumi.get(__ret__, 'descriptions'),
         id=pulumi.get(__ret__, 'id'),
         names=pulumi.get(__ret__, 'names'))
-
-
-@_utilities.lift_output_func(get_datacenters)
 def get_datacenters_output(datacenter_ids: Optional[pulumi.Input[Optional[Sequence[str]]]] = None,
                            descriptions: Optional[pulumi.Input[Optional[Sequence[str]]]] = None,
                            id: Optional[pulumi.Input[Optional[str]]] = None,
@@ -138,4 +140,16 @@ def get_datacenters_output(datacenter_ids: Optional[pulumi.Input[Optional[Sequen
     :param Sequence[str] descriptions: (list) List of all datacenter descriptions. **Deprecated**: Use `datacenters` attribute instead.
     :param Sequence[str] names: (list) List of datacenter names. **Deprecated**: Use `datacenters` attribute instead.
     """
-    ...
+    __args__ = dict()
+    __args__['datacenterIds'] = datacenter_ids
+    __args__['descriptions'] = descriptions
+    __args__['id'] = id
+    __args__['names'] = names
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('hcloud:index/getDatacenters:getDatacenters', __args__, opts=opts, typ=GetDatacentersResult)
+    return __ret__.apply(lambda __response__: GetDatacentersResult(
+        datacenter_ids=pulumi.get(__response__, 'datacenter_ids'),
+        datacenters=pulumi.get(__response__, 'datacenters'),
+        descriptions=pulumi.get(__response__, 'descriptions'),
+        id=pulumi.get(__response__, 'id'),
+        names=pulumi.get(__response__, 'names')))

pulumi_hcloud/get_firewall.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
 from . import outputs
 from ._inputs import *
@@ -159,9 +164,6 @@ def get_firewall(apply_tos: Optional[Sequence[Union['GetFirewallApplyToArgs', 'G
         name=pulumi.get(__ret__, 'name'),
         rules=pulumi.get(__ret__, 'rules'),
         with_selector=pulumi.get(__ret__, 'with_selector'))
-
-
-@_utilities.lift_output_func(get_firewall)
 def get_firewall_output(apply_tos: Optional[pulumi.Input[Optional[Sequence[Union['GetFirewallApplyToArgs', 'GetFirewallApplyToArgsDict']]]]] = None,
                         id: Optional[pulumi.Input[Optional[int]]] = None,
                         labels: Optional[pulumi.Input[Optional[Mapping[str, str]]]] = None,
@@ -190,4 +192,21 @@ def get_firewall_output(apply_tos: Optional[pulumi.Input[Optional[Sequence[Union
     :param Sequence[Union['GetFirewallRuleArgs', 'GetFirewallRuleArgsDict']] rules: (string)  Configuration of a Rule from this Firewall.
     :param str with_selector: [Label selector](https://docs.hetzner.cloud/#overview-label-selector)
     """
-    ...
+    __args__ = dict()
+    __args__['applyTos'] = apply_tos
+    __args__['id'] = id
+    __args__['labels'] = labels
+    __args__['mostRecent'] = most_recent
+    __args__['name'] = name
+    __args__['rules'] = rules
+    __args__['withSelector'] = with_selector
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('hcloud:index/getFirewall:getFirewall', __args__, opts=opts, typ=GetFirewallResult)
+    return __ret__.apply(lambda __response__: GetFirewallResult(
+        apply_tos=pulumi.get(__response__, 'apply_tos'),
+        id=pulumi.get(__response__, 'id'),
+        labels=pulumi.get(__response__, 'labels'),
+        most_recent=pulumi.get(__response__, 'most_recent'),
+        name=pulumi.get(__response__, 'name'),
+        rules=pulumi.get(__response__, 'rules'),
+        with_selector=pulumi.get(__response__, 'with_selector')))