pulumi-harness 0.6.0a1741240126__py3-none-any.whl → 0.6.0a1741413027__py3-none-any.whl

pulumi_harness/platform/feature_flag.py

@@ -29,6 +29,7 @@ class FeatureFlagArgs:
                  permanent: pulumi.Input[bool],
                  project_id: pulumi.Input[str],
                  variations: pulumi.Input[Sequence[pulumi.Input['FeatureFlagVariationArgs']]],
+                 archived: Optional[pulumi.Input[bool]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  environments: Optional[pulumi.Input[Sequence[pulumi.Input['FeatureFlagEnvironmentArgs']]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
@@ -44,6 +45,7 @@ class FeatureFlagArgs:
         :param pulumi.Input[bool] permanent: Whether or not the flag is permanent. If it is, it will never be flagged as stale
         :param pulumi.Input[str] project_id: Project Identifier
         :param pulumi.Input[Sequence[pulumi.Input['FeatureFlagVariationArgs']]] variations: The options available for your flag
+        :param pulumi.Input[bool] archived: Whether or not the flag is archived.
         :param pulumi.Input[str] description: Description of the Feature Flag
         :param pulumi.Input[Sequence[pulumi.Input['FeatureFlagEnvironmentArgs']]] environments: Environment Identifier
         :param pulumi.Input[str] name: Name of the Feature Flag
@@ -58,6 +60,8 @@ class FeatureFlagArgs:
         pulumi.set(__self__, "permanent", permanent)
         pulumi.set(__self__, "project_id", project_id)
         pulumi.set(__self__, "variations", variations)
+        if archived is not None:
+            pulumi.set(__self__, "archived", archived)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if environments is not None:
@@ -165,6 +169,18 @@ class FeatureFlagArgs:
     def variations(self, value: pulumi.Input[Sequence[pulumi.Input['FeatureFlagVariationArgs']]]):
         pulumi.set(self, "variations", value)
 
+    @property
+    @pulumi.getter
+    def archived(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether or not the flag is archived.
+        """
+        return pulumi.get(self, "archived")
+
+    @archived.setter
+    def archived(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "archived", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -229,6 +245,7 @@ class FeatureFlagArgs:
 @pulumi.input_type
 class _FeatureFlagState:
     def __init__(__self__, *,
+                 archived: Optional[pulumi.Input[bool]] = None,
                  default_off_variation: Optional[pulumi.Input[str]] = None,
                  default_on_variation: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -244,6 +261,7 @@ class _FeatureFlagState:
                  variations: Optional[pulumi.Input[Sequence[pulumi.Input['FeatureFlagVariationArgs']]]] = None):
         """
         Input properties used for looking up and filtering FeatureFlag resources.
+        :param pulumi.Input[bool] archived: Whether or not the flag is archived.
         :param pulumi.Input[str] default_off_variation: Which of the variations to use when the flag is toggled to off state
         :param pulumi.Input[str] default_on_variation: Which of the variations to use when the flag is toggled to on state
         :param pulumi.Input[str] description: Description of the Feature Flag
@@ -258,6 +276,8 @@ class _FeatureFlagState:
         :param pulumi.Input[Sequence[pulumi.Input['FeatureFlagTagArgs']]] tags: The tags for the flag
         :param pulumi.Input[Sequence[pulumi.Input['FeatureFlagVariationArgs']]] variations: The options available for your flag
         """
+        if archived is not None:
+            pulumi.set(__self__, "archived", archived)
         if default_off_variation is not None:
             pulumi.set(__self__, "default_off_variation", default_off_variation)
         if default_on_variation is not None:
@@ -285,6 +305,18 @@ class _FeatureFlagState:
         if variations is not None:
             pulumi.set(__self__, "variations", variations)
 
+    @property
+    @pulumi.getter
+    def archived(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether or not the flag is archived.
+        """
+        return pulumi.get(self, "archived")
+
+    @archived.setter
+    def archived(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "archived", value)
+
     @property
     @pulumi.getter(name="defaultOffVariation")
     def default_off_variation(self) -> Optional[pulumi.Input[str]]:
@@ -447,6 +479,7 @@ class FeatureFlag(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 archived: Optional[pulumi.Input[bool]] = None,
                  default_off_variation: Optional[pulumi.Input[str]] = None,
                  default_on_variation: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -466,6 +499,7 @@ class FeatureFlag(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[bool] archived: Whether or not the flag is archived.
         :param pulumi.Input[str] default_off_variation: Which of the variations to use when the flag is toggled to off state
         :param pulumi.Input[str] default_on_variation: Which of the variations to use when the flag is toggled to on state
         :param pulumi.Input[str] description: Description of the Feature Flag
@@ -504,6 +538,7 @@ class FeatureFlag(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
+                 archived: Optional[pulumi.Input[bool]] = None,
                  default_off_variation: Optional[pulumi.Input[str]] = None,
                  default_on_variation: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -526,6 +561,7 @@ class FeatureFlag(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = FeatureFlagArgs.__new__(FeatureFlagArgs)
 
+            __props__.__dict__["archived"] = archived
             if default_off_variation is None and not opts.urn:
                 raise TypeError("Missing required property 'default_off_variation'")
             __props__.__dict__["default_off_variation"] = default_off_variation
@@ -565,6 +601,7 @@ class FeatureFlag(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
+            archived: Optional[pulumi.Input[bool]] = None,
             default_off_variation: Optional[pulumi.Input[str]] = None,
             default_on_variation: Optional[pulumi.Input[str]] = None,
             description: Optional[pulumi.Input[str]] = None,
@@ -585,6 +622,7 @@ class FeatureFlag(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
+        :param pulumi.Input[bool] archived: Whether or not the flag is archived.
         :param pulumi.Input[str] default_off_variation: Which of the variations to use when the flag is toggled to off state
         :param pulumi.Input[str] default_on_variation: Which of the variations to use when the flag is toggled to on state
         :param pulumi.Input[str] description: Description of the Feature Flag
@@ -603,6 +641,7 @@ class FeatureFlag(pulumi.CustomResource):
 
         __props__ = _FeatureFlagState.__new__(_FeatureFlagState)
 
+        __props__.__dict__["archived"] = archived
         __props__.__dict__["default_off_variation"] = default_off_variation
         __props__.__dict__["default_on_variation"] = default_on_variation
         __props__.__dict__["description"] = description
@@ -618,6 +657,14 @@ class FeatureFlag(pulumi.CustomResource):
         __props__.__dict__["variations"] = variations
         return FeatureFlag(resource_name, opts=opts, __props__=__props__)
 
+    @property
+    @pulumi.getter
+    def archived(self) -> pulumi.Output[Optional[bool]]:
+        """
+        Whether or not the flag is archived.
+        """
+        return pulumi.get(self, "archived")
+
     @property
     @pulumi.getter(name="defaultOffVariation")
     def default_off_variation(self) -> pulumi.Output[str]:

pulumi_harness/platform/get_gitops_agent_operator_yaml.py

@@ -0,0 +1,250 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+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 *
+
+__all__ = [
+    'GetGitopsAgentOperatorYamlResult',
+    'AwaitableGetGitopsAgentOperatorYamlResult',
+    'get_gitops_agent_operator_yaml',
+    'get_gitops_agent_operator_yaml_output',
+]
+
+@pulumi.output_type
+class GetGitopsAgentOperatorYamlResult:
+    """
+    A collection of values returned by getGitopsAgentOperatorYaml.
+    """
+    def __init__(__self__, ca_data=None, id=None, identifier=None, namespace=None, org_id=None, private_key=None, project_id=None, proxies=None, skip_crds=None, yaml=None):
+        if ca_data and not isinstance(ca_data, str):
+            raise TypeError("Expected argument 'ca_data' to be a str")
+        pulumi.set(__self__, "ca_data", ca_data)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if identifier and not isinstance(identifier, str):
+            raise TypeError("Expected argument 'identifier' to be a str")
+        pulumi.set(__self__, "identifier", identifier)
+        if namespace and not isinstance(namespace, str):
+            raise TypeError("Expected argument 'namespace' to be a str")
+        pulumi.set(__self__, "namespace", namespace)
+        if org_id and not isinstance(org_id, str):
+            raise TypeError("Expected argument 'org_id' to be a str")
+        pulumi.set(__self__, "org_id", org_id)
+        if private_key and not isinstance(private_key, str):
+            raise TypeError("Expected argument 'private_key' to be a str")
+        pulumi.set(__self__, "private_key", private_key)
+        if project_id and not isinstance(project_id, str):
+            raise TypeError("Expected argument 'project_id' to be a str")
+        pulumi.set(__self__, "project_id", project_id)
+        if proxies and not isinstance(proxies, list):
+            raise TypeError("Expected argument 'proxies' to be a list")
+        pulumi.set(__self__, "proxies", proxies)
+        if skip_crds and not isinstance(skip_crds, bool):
+            raise TypeError("Expected argument 'skip_crds' to be a bool")
+        pulumi.set(__self__, "skip_crds", skip_crds)
+        if yaml and not isinstance(yaml, str):
+            raise TypeError("Expected argument 'yaml' to be a str")
+        pulumi.set(__self__, "yaml", yaml)
+
+    @property
+    @pulumi.getter(name="caData")
+    def ca_data(self) -> Optional[str]:
+        """
+        CA data of the GitOps agent, base64 encoded content of ca chain.
+        """
+        return pulumi.get(self, "ca_data")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def identifier(self) -> str:
+        """
+        Identifier of the GitOps agent.
+        """
+        return pulumi.get(self, "identifier")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> str:
+        """
+        The kubernetes namespace where the agent is installed.
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter(name="orgId")
+    def org_id(self) -> Optional[str]:
+        """
+        Organization identifier of the GitOps agent.
+        """
+        return pulumi.get(self, "org_id")
+
+    @property
+    @pulumi.getter(name="privateKey")
+    def private_key(self) -> Optional[str]:
+        """
+        Private key for the GitOps agent. If provided authentication token will not be regenerated. Must be base64 encoded.
+        """
+        return pulumi.get(self, "private_key")
+
+    @property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> Optional[str]:
+        """
+        Project identifier of the GitOps agent.
+        """
+        return pulumi.get(self, "project_id")
+
+    @property
+    @pulumi.getter
+    def proxies(self) -> Optional[Sequence['outputs.GetGitopsAgentOperatorYamlProxyResult']]:
+        """
+        Proxy settings for the GitOps agent.
+        """
+        return pulumi.get(self, "proxies")
+
+    @property
+    @pulumi.getter(name="skipCrds")
+    def skip_crds(self) -> Optional[bool]:
+        """
+        Skip CRDs for the GitOps agent.
+        """
+        return pulumi.get(self, "skip_crds")
+
+    @property
+    @pulumi.getter
+    def yaml(self) -> str:
+        """
+        The operator manifest YAML of the GitOps agent.
+        """
+        return pulumi.get(self, "yaml")
+
+
+class AwaitableGetGitopsAgentOperatorYamlResult(GetGitopsAgentOperatorYamlResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetGitopsAgentOperatorYamlResult(
+            ca_data=self.ca_data,
+            id=self.id,
+            identifier=self.identifier,
+            namespace=self.namespace,
+            org_id=self.org_id,
+            private_key=self.private_key,
+            project_id=self.project_id,
+            proxies=self.proxies,
+            skip_crds=self.skip_crds,
+            yaml=self.yaml)
+
+
+def get_gitops_agent_operator_yaml(ca_data: Optional[str] = None,
+                                   identifier: Optional[str] = None,
+                                   namespace: Optional[str] = None,
+                                   org_id: Optional[str] = None,
+                                   private_key: Optional[str] = None,
+                                   project_id: Optional[str] = None,
+                                   proxies: Optional[Sequence[Union['GetGitopsAgentOperatorYamlProxyArgs', 'GetGitopsAgentOperatorYamlProxyArgsDict']]] = None,
+                                   skip_crds: Optional[bool] = None,
+                                   opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGitopsAgentOperatorYamlResult:
+    """
+    Datasource for fetching a Harness Gitops Agent operator manifest YAML.
+
+
+    :param str ca_data: CA data of the GitOps agent, base64 encoded content of ca chain.
+    :param str identifier: Identifier of the GitOps agent.
+    :param str namespace: The kubernetes namespace where the agent is installed.
+    :param str org_id: Organization identifier of the GitOps agent.
+    :param str private_key: Private key for the GitOps agent. If provided authentication token will not be regenerated. Must be base64 encoded.
+    :param str project_id: Project identifier of the GitOps agent.
+    :param Sequence[Union['GetGitopsAgentOperatorYamlProxyArgs', 'GetGitopsAgentOperatorYamlProxyArgsDict']] proxies: Proxy settings for the GitOps agent.
+    :param bool skip_crds: Skip CRDs for the GitOps agent.
+    """
+    __args__ = dict()
+    __args__['caData'] = ca_data
+    __args__['identifier'] = identifier
+    __args__['namespace'] = namespace
+    __args__['orgId'] = org_id
+    __args__['privateKey'] = private_key
+    __args__['projectId'] = project_id
+    __args__['proxies'] = proxies
+    __args__['skipCrds'] = skip_crds
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('harness:platform/getGitopsAgentOperatorYaml:getGitopsAgentOperatorYaml', __args__, opts=opts, typ=GetGitopsAgentOperatorYamlResult).value
+
+    return AwaitableGetGitopsAgentOperatorYamlResult(
+        ca_data=pulumi.get(__ret__, 'ca_data'),
+        id=pulumi.get(__ret__, 'id'),
+        identifier=pulumi.get(__ret__, 'identifier'),
+        namespace=pulumi.get(__ret__, 'namespace'),
+        org_id=pulumi.get(__ret__, 'org_id'),
+        private_key=pulumi.get(__ret__, 'private_key'),
+        project_id=pulumi.get(__ret__, 'project_id'),
+        proxies=pulumi.get(__ret__, 'proxies'),
+        skip_crds=pulumi.get(__ret__, 'skip_crds'),
+        yaml=pulumi.get(__ret__, 'yaml'))
+def get_gitops_agent_operator_yaml_output(ca_data: Optional[pulumi.Input[Optional[str]]] = None,
+                                          identifier: Optional[pulumi.Input[str]] = None,
+                                          namespace: Optional[pulumi.Input[str]] = None,
+                                          org_id: Optional[pulumi.Input[Optional[str]]] = None,
+                                          private_key: Optional[pulumi.Input[Optional[str]]] = None,
+                                          project_id: Optional[pulumi.Input[Optional[str]]] = None,
+                                          proxies: Optional[pulumi.Input[Optional[Sequence[Union['GetGitopsAgentOperatorYamlProxyArgs', 'GetGitopsAgentOperatorYamlProxyArgsDict']]]]] = None,
+                                          skip_crds: Optional[pulumi.Input[Optional[bool]]] = None,
+                                          opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetGitopsAgentOperatorYamlResult]:
+    """
+    Datasource for fetching a Harness Gitops Agent operator manifest YAML.
+
+
+    :param str ca_data: CA data of the GitOps agent, base64 encoded content of ca chain.
+    :param str identifier: Identifier of the GitOps agent.
+    :param str namespace: The kubernetes namespace where the agent is installed.
+    :param str org_id: Organization identifier of the GitOps agent.
+    :param str private_key: Private key for the GitOps agent. If provided authentication token will not be regenerated. Must be base64 encoded.
+    :param str project_id: Project identifier of the GitOps agent.
+    :param Sequence[Union['GetGitopsAgentOperatorYamlProxyArgs', 'GetGitopsAgentOperatorYamlProxyArgsDict']] proxies: Proxy settings for the GitOps agent.
+    :param bool skip_crds: Skip CRDs for the GitOps agent.
+    """
+    __args__ = dict()
+    __args__['caData'] = ca_data
+    __args__['identifier'] = identifier
+    __args__['namespace'] = namespace
+    __args__['orgId'] = org_id
+    __args__['privateKey'] = private_key
+    __args__['projectId'] = project_id
+    __args__['proxies'] = proxies
+    __args__['skipCrds'] = skip_crds
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('harness:platform/getGitopsAgentOperatorYaml:getGitopsAgentOperatorYaml', __args__, opts=opts, typ=GetGitopsAgentOperatorYamlResult)
+    return __ret__.apply(lambda __response__: GetGitopsAgentOperatorYamlResult(
+        ca_data=pulumi.get(__response__, 'ca_data'),
+        id=pulumi.get(__response__, 'id'),
+        identifier=pulumi.get(__response__, 'identifier'),
+        namespace=pulumi.get(__response__, 'namespace'),
+        org_id=pulumi.get(__response__, 'org_id'),
+        private_key=pulumi.get(__response__, 'private_key'),
+        project_id=pulumi.get(__response__, 'project_id'),
+        proxies=pulumi.get(__response__, 'proxies'),
+        skip_crds=pulumi.get(__response__, 'skip_crds'),
+        yaml=pulumi.get(__response__, 'yaml')))

pulumi_harness/platform/get_vault_connector.py

@@ -26,7 +26,7 @@ class GetVaultConnectorResult:
     """
     A collection of values returned by getVaultConnector.
     """
-    def __init__(__self__, access_type=None, app_role_id=None, auth_token=None, aws_region=None, base_path=None, default=None, delegate_selectors=None, description=None, id=None, identifier=None, is_default=None, is_read_only=None, k8s_auth_endpoint=None, name=None, namespace=None, org_id=None, project_id=None, read_only=None, renew_app_role_token=None, renewal_interval_minutes=None, secret_engine_manually_configured=None, secret_engine_name=None, secret_engine_version=None, secret_id=None, service_account_token_path=None, sink_path=None, tags=None, use_aws_iam=None, use_k8s_auth=None, use_vault_agent=None, vault_aws_iam_role=None, vault_k8s_auth_role=None, vault_url=None, xvault_aws_iam_server_id=None):
+    def __init__(__self__, access_type=None, app_role_id=None, auth_token=None, aws_region=None, base_path=None, default=None, delegate_selectors=None, description=None, execute_on_delegate=None, id=None, identifier=None, is_default=None, is_read_only=None, k8s_auth_endpoint=None, name=None, namespace=None, org_id=None, project_id=None, read_only=None, renew_app_role_token=None, renewal_interval_minutes=None, secret_engine_manually_configured=None, secret_engine_name=None, secret_engine_version=None, secret_id=None, service_account_token_path=None, sink_path=None, tags=None, use_aws_iam=None, use_jwt_auth=None, use_k8s_auth=None, use_vault_agent=None, vault_aws_iam_role=None, vault_jwt_auth_path=None, vault_jwt_auth_role=None, vault_k8s_auth_role=None, vault_url=None, xvault_aws_iam_server_id=None):
         if access_type and not isinstance(access_type, str):
             raise TypeError("Expected argument 'access_type' to be a str")
         pulumi.set(__self__, "access_type", access_type)
@@ -51,6 +51,9 @@ class GetVaultConnectorResult:
         if description and not isinstance(description, str):
             raise TypeError("Expected argument 'description' to be a str")
         pulumi.set(__self__, "description", description)
+        if execute_on_delegate and not isinstance(execute_on_delegate, bool):
+            raise TypeError("Expected argument 'execute_on_delegate' to be a bool")
+        pulumi.set(__self__, "execute_on_delegate", execute_on_delegate)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
@@ -111,6 +114,9 @@ class GetVaultConnectorResult:
         if use_aws_iam and not isinstance(use_aws_iam, bool):
             raise TypeError("Expected argument 'use_aws_iam' to be a bool")
         pulumi.set(__self__, "use_aws_iam", use_aws_iam)
+        if use_jwt_auth and not isinstance(use_jwt_auth, bool):
+            raise TypeError("Expected argument 'use_jwt_auth' to be a bool")
+        pulumi.set(__self__, "use_jwt_auth", use_jwt_auth)
         if use_k8s_auth and not isinstance(use_k8s_auth, bool):
             raise TypeError("Expected argument 'use_k8s_auth' to be a bool")
         pulumi.set(__self__, "use_k8s_auth", use_k8s_auth)
@@ -120,6 +126,12 @@ class GetVaultConnectorResult:
         if vault_aws_iam_role and not isinstance(vault_aws_iam_role, str):
             raise TypeError("Expected argument 'vault_aws_iam_role' to be a str")
         pulumi.set(__self__, "vault_aws_iam_role", vault_aws_iam_role)
+        if vault_jwt_auth_path and not isinstance(vault_jwt_auth_path, str):
+            raise TypeError("Expected argument 'vault_jwt_auth_path' to be a str")
+        pulumi.set(__self__, "vault_jwt_auth_path", vault_jwt_auth_path)
+        if vault_jwt_auth_role and not isinstance(vault_jwt_auth_role, str):
+            raise TypeError("Expected argument 'vault_jwt_auth_role' to be a str")
+        pulumi.set(__self__, "vault_jwt_auth_role", vault_jwt_auth_role)
         if vault_k8s_auth_role and not isinstance(vault_k8s_auth_role, str):
             raise TypeError("Expected argument 'vault_k8s_auth_role' to be a str")
         pulumi.set(__self__, "vault_k8s_auth_role", vault_k8s_auth_role)
@@ -194,6 +206,14 @@ class GetVaultConnectorResult:
         """
         return pulumi.get(self, "description")
 
+    @property
+    @pulumi.getter(name="executeOnDelegate")
+    def execute_on_delegate(self) -> bool:
+        """
+        Execute on delegate or not.
+        """
+        return pulumi.get(self, "execute_on_delegate")
+
     @property
     @pulumi.getter
     def id(self) -> str:
@@ -354,6 +374,14 @@ class GetVaultConnectorResult:
         """
         return pulumi.get(self, "use_aws_iam")
 
+    @property
+    @pulumi.getter(name="useJwtAuth")
+    def use_jwt_auth(self) -> bool:
+        """
+        Boolean value to indicate if JWT is used for authentication.
+        """
+        return pulumi.get(self, "use_jwt_auth")
+
     @property
     @pulumi.getter(name="useK8sAuth")
     def use_k8s_auth(self) -> bool:
@@ -378,6 +406,22 @@ class GetVaultConnectorResult:
         """
         return pulumi.get(self, "vault_aws_iam_role")
 
+    @property
+    @pulumi.getter(name="vaultJwtAuthPath")
+    def vault_jwt_auth_path(self) -> str:
+        """
+        Custom path at with JWT auth in enabled for Vault.
+        """
+        return pulumi.get(self, "vault_jwt_auth_path")
+
+    @property
+    @pulumi.getter(name="vaultJwtAuthRole")
+    def vault_jwt_auth_role(self) -> str:
+        """
+        The Vault role defined with JWT auth type for accessing Vault as per policies binded.
+        """
+        return pulumi.get(self, "vault_jwt_auth_role")
+
     @property
     @pulumi.getter(name="vaultK8sAuthRole")
     def vault_k8s_auth_role(self) -> str:
@@ -417,6 +461,7 @@ class AwaitableGetVaultConnectorResult(GetVaultConnectorResult):
             default=self.default,
             delegate_selectors=self.delegate_selectors,
             description=self.description,
+            execute_on_delegate=self.execute_on_delegate,
             id=self.id,
             identifier=self.identifier,
             is_default=self.is_default,
@@ -437,9 +482,12 @@ class AwaitableGetVaultConnectorResult(GetVaultConnectorResult):
             sink_path=self.sink_path,
             tags=self.tags,
             use_aws_iam=self.use_aws_iam,
+            use_jwt_auth=self.use_jwt_auth,
             use_k8s_auth=self.use_k8s_auth,
             use_vault_agent=self.use_vault_agent,
             vault_aws_iam_role=self.vault_aws_iam_role,
+            vault_jwt_auth_path=self.vault_jwt_auth_path,
+            vault_jwt_auth_role=self.vault_jwt_auth_role,
             vault_k8s_auth_role=self.vault_k8s_auth_role,
             vault_url=self.vault_url,
             xvault_aws_iam_server_id=self.xvault_aws_iam_server_id)
@@ -483,6 +531,7 @@ def get_vault_connector(identifier: Optional[str] = None,
         default=pulumi.get(__ret__, 'default'),
         delegate_selectors=pulumi.get(__ret__, 'delegate_selectors'),
         description=pulumi.get(__ret__, 'description'),
+        execute_on_delegate=pulumi.get(__ret__, 'execute_on_delegate'),
         id=pulumi.get(__ret__, 'id'),
         identifier=pulumi.get(__ret__, 'identifier'),
         is_default=pulumi.get(__ret__, 'is_default'),
@@ -503,9 +552,12 @@ def get_vault_connector(identifier: Optional[str] = None,
         sink_path=pulumi.get(__ret__, 'sink_path'),
         tags=pulumi.get(__ret__, 'tags'),
         use_aws_iam=pulumi.get(__ret__, 'use_aws_iam'),
+        use_jwt_auth=pulumi.get(__ret__, 'use_jwt_auth'),
         use_k8s_auth=pulumi.get(__ret__, 'use_k8s_auth'),
         use_vault_agent=pulumi.get(__ret__, 'use_vault_agent'),
         vault_aws_iam_role=pulumi.get(__ret__, 'vault_aws_iam_role'),
+        vault_jwt_auth_path=pulumi.get(__ret__, 'vault_jwt_auth_path'),
+        vault_jwt_auth_role=pulumi.get(__ret__, 'vault_jwt_auth_role'),
         vault_k8s_auth_role=pulumi.get(__ret__, 'vault_k8s_auth_role'),
         vault_url=pulumi.get(__ret__, 'vault_url'),
         xvault_aws_iam_server_id=pulumi.get(__ret__, 'xvault_aws_iam_server_id'))
@@ -546,6 +598,7 @@ def get_vault_connector_output(identifier: Optional[pulumi.Input[str]] = None,
         default=pulumi.get(__response__, 'default'),
         delegate_selectors=pulumi.get(__response__, 'delegate_selectors'),
         description=pulumi.get(__response__, 'description'),
+        execute_on_delegate=pulumi.get(__response__, 'execute_on_delegate'),
         id=pulumi.get(__response__, 'id'),
         identifier=pulumi.get(__response__, 'identifier'),
         is_default=pulumi.get(__response__, 'is_default'),
@@ -566,9 +619,12 @@ def get_vault_connector_output(identifier: Optional[pulumi.Input[str]] = None,
         sink_path=pulumi.get(__response__, 'sink_path'),
         tags=pulumi.get(__response__, 'tags'),
         use_aws_iam=pulumi.get(__response__, 'use_aws_iam'),
+        use_jwt_auth=pulumi.get(__response__, 'use_jwt_auth'),
         use_k8s_auth=pulumi.get(__response__, 'use_k8s_auth'),
         use_vault_agent=pulumi.get(__response__, 'use_vault_agent'),
         vault_aws_iam_role=pulumi.get(__response__, 'vault_aws_iam_role'),
+        vault_jwt_auth_path=pulumi.get(__response__, 'vault_jwt_auth_path'),
+        vault_jwt_auth_role=pulumi.get(__response__, 'vault_jwt_auth_role'),
         vault_k8s_auth_role=pulumi.get(__response__, 'vault_k8s_auth_role'),
         vault_url=pulumi.get(__response__, 'vault_url'),
         xvault_aws_iam_server_id=pulumi.get(__response__, 'xvault_aws_iam_server_id')))