pulumi-nomad 2.1.0a1698259788__py3-none-any.whl → 2.1.0a1698477283__py3-none-any.whl

pulumi_nomad/_utilities.py

@@ -246,24 +246,5 @@ def lift_output_func(func: typing.Any) -> typing.Callable[[_F], _F]:
 
     return (lambda _: lifted_func)
 
-
-def configure(val, cls: type, input: bool):
-    def _apply(v):
-        if isinstance(v, typing.Mapping):
-            def _setter(key, value):
-                v[key] = value
-            cls._configure(_setter, **v)
-        return v
-
-    # Check that cls has a static _configure method. External classes may
-    # not have it if it was generated with older codegen.
-    if hasattr(cls, "_configure"):
-        if isinstance(val, typing.Mapping):
-            return _apply(val)
-        elif input and val is not None and not isinstance(val, cls):
-            return pulumi.Output.from_input(val).apply(_apply)
-
-    return val
-
 def get_plugin_download_url():
 	return None

pulumi_nomad/acl_auth_method.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
 from ._inputs import *
@@ -36,47 +36,14 @@ class AclAuthMethodArgs:
                as default.
         :param pulumi.Input[str] name: `(string: <required>)` - The identifier of the ACL Auth Method.
         """
-        AclAuthMethodArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            config=config,
-            max_token_ttl=max_token_ttl,
-            token_locality=token_locality,
-            type=type,
-            default=default,
-            name=name,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             config: Optional[pulumi.Input['AclAuthMethodConfigArgs']] = None,
-             max_token_ttl: Optional[pulumi.Input[str]] = None,
-             token_locality: Optional[pulumi.Input[str]] = None,
-             type: Optional[pulumi.Input[str]] = None,
-             default: Optional[pulumi.Input[bool]] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if config is None:
-            raise TypeError("Missing 'config' argument")
-        if max_token_ttl is None and 'maxTokenTtl' in kwargs:
-            max_token_ttl = kwargs['maxTokenTtl']
-        if max_token_ttl is None:
-            raise TypeError("Missing 'max_token_ttl' argument")
-        if token_locality is None and 'tokenLocality' in kwargs:
-            token_locality = kwargs['tokenLocality']
-        if token_locality is None:
-            raise TypeError("Missing 'token_locality' argument")
-        if type is None:
-            raise TypeError("Missing 'type' argument")
-
-        _setter("config", config)
-        _setter("max_token_ttl", max_token_ttl)
-        _setter("token_locality", token_locality)
-        _setter("type", type)
+        pulumi.set(__self__, "config", config)
+        pulumi.set(__self__, "max_token_ttl", max_token_ttl)
+        pulumi.set(__self__, "token_locality", token_locality)
+        pulumi.set(__self__, "type", type)
         if default is not None:
-            _setter("default", default)
+            pulumi.set(__self__, "default", default)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
 
     @property
     @pulumi.getter
@@ -179,43 +146,18 @@ class _AclAuthMethodState:
         :param pulumi.Input[str] type: `(string: <required>)` - ACL Auth Method SSO workflow type. Currently,
                the only supported type is `OIDC`.
         """
-        _AclAuthMethodState._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            config=config,
-            default=default,
-            max_token_ttl=max_token_ttl,
-            name=name,
-            token_locality=token_locality,
-            type=type,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             config: Optional[pulumi.Input['AclAuthMethodConfigArgs']] = None,
-             default: Optional[pulumi.Input[bool]] = None,
-             max_token_ttl: Optional[pulumi.Input[str]] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             token_locality: Optional[pulumi.Input[str]] = None,
-             type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if max_token_ttl is None and 'maxTokenTtl' in kwargs:
-            max_token_ttl = kwargs['maxTokenTtl']
-        if token_locality is None and 'tokenLocality' in kwargs:
-            token_locality = kwargs['tokenLocality']
-
         if config is not None:
-            _setter("config", config)
+            pulumi.set(__self__, "config", config)
         if default is not None:
-            _setter("default", default)
+            pulumi.set(__self__, "default", default)
         if max_token_ttl is not None:
-            _setter("max_token_ttl", max_token_ttl)
+            pulumi.set(__self__, "max_token_ttl", max_token_ttl)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
         if token_locality is not None:
-            _setter("token_locality", token_locality)
+            pulumi.set(__self__, "token_locality", token_locality)
         if type is not None:
-            _setter("type", type)
+            pulumi.set(__self__, "type", type)
 
     @property
     @pulumi.getter
@@ -399,10 +341,6 @@ class AclAuthMethod(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            AclAuthMethodArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,
@@ -423,7 +361,6 @@ class AclAuthMethod(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = AclAuthMethodArgs.__new__(AclAuthMethodArgs)
 
-            config = _utilities.configure(config, AclAuthMethodConfigArgs, True)
             if config is None and not opts.urn:
                 raise TypeError("Missing required property 'config'")
             __props__.__dict__["config"] = config

pulumi_nomad/acl_binding_rule.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 
 __all__ = ['AclBindingRuleArgs', 'AclBindingRule']
@@ -32,43 +32,14 @@ class AclBindingRuleArgs:
         :param pulumi.Input[str] selector: `(string: "")` - A boolean expression that matches against verified
                identity attributes returned from the auth method during login.
         """
-        AclBindingRuleArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            auth_method=auth_method,
-            bind_type=bind_type,
-            bind_name=bind_name,
-            description=description,
-            selector=selector,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             auth_method: Optional[pulumi.Input[str]] = None,
-             bind_type: Optional[pulumi.Input[str]] = None,
-             bind_name: Optional[pulumi.Input[str]] = None,
-             description: Optional[pulumi.Input[str]] = None,
-             selector: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if auth_method is None and 'authMethod' in kwargs:
-            auth_method = kwargs['authMethod']
-        if auth_method is None:
-            raise TypeError("Missing 'auth_method' argument")
-        if bind_type is None and 'bindType' in kwargs:
-            bind_type = kwargs['bindType']
-        if bind_type is None:
-            raise TypeError("Missing 'bind_type' argument")
-        if bind_name is None and 'bindName' in kwargs:
-            bind_name = kwargs['bindName']
-
-        _setter("auth_method", auth_method)
-        _setter("bind_type", bind_type)
+        pulumi.set(__self__, "auth_method", auth_method)
+        pulumi.set(__self__, "bind_type", bind_type)
         if bind_name is not None:
-            _setter("bind_name", bind_name)
+            pulumi.set(__self__, "bind_name", bind_name)
         if description is not None:
-            _setter("description", description)
+            pulumi.set(__self__, "description", description)
         if selector is not None:
-            _setter("selector", selector)
+            pulumi.set(__self__, "selector", selector)
 
     @property
     @pulumi.getter(name="authMethod")
@@ -157,41 +128,16 @@ class _AclBindingRuleState:
         :param pulumi.Input[str] selector: `(string: "")` - A boolean expression that matches against verified
                identity attributes returned from the auth method during login.
         """
-        _AclBindingRuleState._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            auth_method=auth_method,
-            bind_name=bind_name,
-            bind_type=bind_type,
-            description=description,
-            selector=selector,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             auth_method: Optional[pulumi.Input[str]] = None,
-             bind_name: Optional[pulumi.Input[str]] = None,
-             bind_type: Optional[pulumi.Input[str]] = None,
-             description: Optional[pulumi.Input[str]] = None,
-             selector: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if auth_method is None and 'authMethod' in kwargs:
-            auth_method = kwargs['authMethod']
-        if bind_name is None and 'bindName' in kwargs:
-            bind_name = kwargs['bindName']
-        if bind_type is None and 'bindType' in kwargs:
-            bind_type = kwargs['bindType']
-
         if auth_method is not None:
-            _setter("auth_method", auth_method)
+            pulumi.set(__self__, "auth_method", auth_method)
         if bind_name is not None:
-            _setter("bind_name", bind_name)
+            pulumi.set(__self__, "bind_name", bind_name)
         if bind_type is not None:
-            _setter("bind_type", bind_type)
+            pulumi.set(__self__, "bind_type", bind_type)
         if description is not None:
-            _setter("description", description)
+            pulumi.set(__self__, "description", description)
         if selector is not None:
-            _setter("selector", selector)
+            pulumi.set(__self__, "selector", selector)
 
     @property
     @pulumi.getter(name="authMethod")
@@ -303,10 +249,6 @@ class AclBindingRule(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            AclBindingRuleArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,

pulumi_nomad/acl_policy.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
 from ._inputs import *
@@ -28,36 +28,13 @@ class AclPolicyArgs:
         :param pulumi.Input['AclPolicyJobAclArgs'] job_acl: `(``JobACL``: <optional>)` - Options for assigning the ACL rules to a job, group, or task.
         :param pulumi.Input[str] name: `(string: <required>)` - A unique name for the policy.
         """
-        AclPolicyArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            rules_hcl=rules_hcl,
-            description=description,
-            job_acl=job_acl,
-            name=name,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             rules_hcl: Optional[pulumi.Input[str]] = None,
-             description: Optional[pulumi.Input[str]] = None,
-             job_acl: Optional[pulumi.Input['AclPolicyJobAclArgs']] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if rules_hcl is None and 'rulesHcl' in kwargs:
-            rules_hcl = kwargs['rulesHcl']
-        if rules_hcl is None:
-            raise TypeError("Missing 'rules_hcl' argument")
-        if job_acl is None and 'jobAcl' in kwargs:
-            job_acl = kwargs['jobAcl']
-
-        _setter("rules_hcl", rules_hcl)
+        pulumi.set(__self__, "rules_hcl", rules_hcl)
         if description is not None:
-            _setter("description", description)
+            pulumi.set(__self__, "description", description)
         if job_acl is not None:
-            _setter("job_acl", job_acl)
+            pulumi.set(__self__, "job_acl", job_acl)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
 
     @property
     @pulumi.getter(name="rulesHcl")
@@ -124,35 +101,14 @@ class _AclPolicyState:
         :param pulumi.Input[str] rules_hcl: `(string: <required>)` - The contents of the policy to register,
                as HCL or JSON.
         """
-        _AclPolicyState._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            description=description,
-            job_acl=job_acl,
-            name=name,
-            rules_hcl=rules_hcl,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             description: Optional[pulumi.Input[str]] = None,
-             job_acl: Optional[pulumi.Input['AclPolicyJobAclArgs']] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             rules_hcl: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if job_acl is None and 'jobAcl' in kwargs:
-            job_acl = kwargs['jobAcl']
-        if rules_hcl is None and 'rulesHcl' in kwargs:
-            rules_hcl = kwargs['rulesHcl']
-
         if description is not None:
-            _setter("description", description)
+            pulumi.set(__self__, "description", description)
         if job_acl is not None:
-            _setter("job_acl", job_acl)
+            pulumi.set(__self__, "job_acl", job_acl)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
         if rules_hcl is not None:
-            _setter("rules_hcl", rules_hcl)
+            pulumi.set(__self__, "rules_hcl", rules_hcl)
 
     @property
     @pulumi.getter
@@ -300,10 +256,6 @@ class AclPolicy(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            AclPolicyArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,
@@ -323,7 +275,6 @@ class AclPolicy(pulumi.CustomResource):
             __props__ = AclPolicyArgs.__new__(AclPolicyArgs)
 
             __props__.__dict__["description"] = description
-            job_acl = _utilities.configure(job_acl, AclPolicyJobAclArgs, True)
             __props__.__dict__["job_acl"] = job_acl
             __props__.__dict__["name"] = name
             if rules_hcl is None and not opts.urn:

pulumi_nomad/acl_role.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
 from ._inputs import *
@@ -26,28 +26,11 @@ class AclRoleArgs:
         :param pulumi.Input[str] description: `(string: "")` - A description of the ACL Role.
         :param pulumi.Input[str] name: `(string: <required>)` - A human-friendly name for this ACL Role.
         """
-        AclRoleArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            policies=policies,
-            description=description,
-            name=name,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             policies: Optional[pulumi.Input[Sequence[pulumi.Input['AclRolePolicyArgs']]]] = None,
-             description: Optional[pulumi.Input[str]] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if policies is None:
-            raise TypeError("Missing 'policies' argument")
-
-        _setter("policies", policies)
+        pulumi.set(__self__, "policies", policies)
         if description is not None:
-            _setter("description", description)
+            pulumi.set(__self__, "description", description)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
 
     @property
     @pulumi.getter
@@ -100,27 +83,12 @@ class _AclRoleState:
         :param pulumi.Input[Sequence[pulumi.Input['AclRolePolicyArgs']]] policies: `(set: <required>)` - A set of policy names to associate with this
                ACL Role. It may be used multiple times.
         """
-        _AclRoleState._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            description=description,
-            name=name,
-            policies=policies,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             description: Optional[pulumi.Input[str]] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             policies: Optional[pulumi.Input[Sequence[pulumi.Input['AclRolePolicyArgs']]]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-
         if description is not None:
-            _setter("description", description)
+            pulumi.set(__self__, "description", description)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
         if policies is not None:
-            _setter("policies", policies)
+            pulumi.set(__self__, "policies", policies)
 
     @property
     @pulumi.getter
@@ -196,10 +164,6 @@ class AclRole(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            AclRoleArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,

pulumi_nomad/acl_token.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
 from ._inputs import *
@@ -42,44 +42,17 @@ class AclTokenArgs:
         :param pulumi.Input[Sequence[pulumi.Input['AclTokenRoleArgs']]] roles: `(set: [])` - The list of roles attached to the token. Each entry has
                `name` and `id` attributes. It may be used multiple times.
         """
-        AclTokenArgs._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            type=type,
-            expiration_ttl=expiration_ttl,
-            global_=global_,
-            name=name,
-            policies=policies,
-            roles=roles,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             type: Optional[pulumi.Input[str]] = None,
-             expiration_ttl: Optional[pulumi.Input[str]] = None,
-             global_: Optional[pulumi.Input[bool]] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-             roles: Optional[pulumi.Input[Sequence[pulumi.Input['AclTokenRoleArgs']]]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if type is None:
-            raise TypeError("Missing 'type' argument")
-        if expiration_ttl is None and 'expirationTtl' in kwargs:
-            expiration_ttl = kwargs['expirationTtl']
-        if global_ is None and 'global' in kwargs:
-            global_ = kwargs['global']
-
-        _setter("type", type)
+        pulumi.set(__self__, "type", type)
         if expiration_ttl is not None:
-            _setter("expiration_ttl", expiration_ttl)
+            pulumi.set(__self__, "expiration_ttl", expiration_ttl)
         if global_ is not None:
-            _setter("global_", global_)
+            pulumi.set(__self__, "global_", global_)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
         if policies is not None:
-            _setter("policies", policies)
+            pulumi.set(__self__, "policies", policies)
         if roles is not None:
-            _setter("roles", roles)
+            pulumi.set(__self__, "roles", roles)
 
     @property
     @pulumi.getter
@@ -205,67 +178,26 @@ class _AclTokenState:
                for tokens that will have policies associated with them. Use `management`
                for tokens that can perform any action.
         """
-        _AclTokenState._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            accessor_id=accessor_id,
-            create_time=create_time,
-            expiration_time=expiration_time,
-            expiration_ttl=expiration_ttl,
-            global_=global_,
-            name=name,
-            policies=policies,
-            roles=roles,
-            secret_id=secret_id,
-            type=type,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             accessor_id: Optional[pulumi.Input[str]] = None,
-             create_time: Optional[pulumi.Input[str]] = None,
-             expiration_time: Optional[pulumi.Input[str]] = None,
-             expiration_ttl: Optional[pulumi.Input[str]] = None,
-             global_: Optional[pulumi.Input[bool]] = None,
-             name: Optional[pulumi.Input[str]] = None,
-             policies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-             roles: Optional[pulumi.Input[Sequence[pulumi.Input['AclTokenRoleArgs']]]] = None,
-             secret_id: Optional[pulumi.Input[str]] = None,
-             type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if accessor_id is None and 'accessorId' in kwargs:
-            accessor_id = kwargs['accessorId']
-        if create_time is None and 'createTime' in kwargs:
-            create_time = kwargs['createTime']
-        if expiration_time is None and 'expirationTime' in kwargs:
-            expiration_time = kwargs['expirationTime']
-        if expiration_ttl is None and 'expirationTtl' in kwargs:
-            expiration_ttl = kwargs['expirationTtl']
-        if global_ is None and 'global' in kwargs:
-            global_ = kwargs['global']
-        if secret_id is None and 'secretId' in kwargs:
-            secret_id = kwargs['secretId']
-
         if accessor_id is not None:
-            _setter("accessor_id", accessor_id)
+            pulumi.set(__self__, "accessor_id", accessor_id)
         if create_time is not None:
-            _setter("create_time", create_time)
+            pulumi.set(__self__, "create_time", create_time)
         if expiration_time is not None:
-            _setter("expiration_time", expiration_time)
+            pulumi.set(__self__, "expiration_time", expiration_time)
         if expiration_ttl is not None:
-            _setter("expiration_ttl", expiration_ttl)
+            pulumi.set(__self__, "expiration_ttl", expiration_ttl)
         if global_ is not None:
-            _setter("global_", global_)
+            pulumi.set(__self__, "global_", global_)
         if name is not None:
-            _setter("name", name)
+            pulumi.set(__self__, "name", name)
         if policies is not None:
-            _setter("policies", policies)
+            pulumi.set(__self__, "policies", policies)
         if roles is not None:
-            _setter("roles", roles)
+            pulumi.set(__self__, "roles", roles)
         if secret_id is not None:
-            _setter("secret_id", secret_id)
+            pulumi.set(__self__, "secret_id", secret_id)
         if type is not None:
-            _setter("type", type)
+            pulumi.set(__self__, "type", type)
 
     @property
     @pulumi.getter(name="accessorId")
@@ -556,10 +488,6 @@ class AclToken(pulumi.CustomResource):
         if resource_args is not None:
             __self__._internal_init(resource_name, opts, **resource_args.__dict__)
         else:
-            kwargs = kwargs or {}
-            def _setter(key, value):
-                kwargs[key] = value
-            AclTokenArgs._configure(_setter, **kwargs)
             __self__._internal_init(resource_name, *args, **kwargs)
 
     def _internal_init(__self__,

pulumi_nomad/config/outputs.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 
 __all__ = [
@@ -18,25 +18,8 @@ class Headers(dict):
     def __init__(__self__, *,
                  name: str,
                  value: str):
-        Headers._configure(
-            lambda key, value: pulumi.set(__self__, key, value),
-            name=name,
-            value=value,
-        )
-    @staticmethod
-    def _configure(
-             _setter: Callable[[Any, Any], None],
-             name: Optional[str] = None,
-             value: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions] = None,
-             **kwargs):
-        if name is None:
-            raise TypeError("Missing 'name' argument")
-        if value is None:
-            raise TypeError("Missing 'value' argument")
-
-        _setter("name", name)
-        _setter("value", value)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
 
     @property
     @pulumi.getter

pulumi_nomad/config/vars.py

@@ -6,7 +6,7 @@ import copy
 import warnings
 import pulumi
 import pulumi.runtime
-from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
+from typing import Any, Mapping, Optional, Sequence, Union, overload
 from .. import _utilities
 from . import outputs