pulumi-gcp 8.40.0a1754721948__py3-none-any.whl → 8.40.0a1754951145__py3-none-any.whl

pulumi_gcp/diagflow/outputs.py

@@ -83,6 +83,10 @@ __all__ = [
     'CxGenerativeSettingsGenerativeSafetySettingsBannedPhrase',
     'CxGenerativeSettingsKnowledgeConnectorSettings',
     'CxGenerativeSettingsLlmModelSettings',
+    'CxGeneratorLlmModelSettings',
+    'CxGeneratorModelParameter',
+    'CxGeneratorPlaceholder',
+    'CxGeneratorPromptText',
     'CxIntentParameter',
     'CxIntentTrainingPhrase',
     'CxIntentTrainingPhrasePart',
@@ -207,8 +211,12 @@ __all__ = [
     'CxToolOpenApiSpecTlsConfigCaCert',
     'CxVersionNluSetting',
     'CxWebhookGenericWebService',
+    'CxWebhookGenericWebServiceOauthConfig',
+    'CxWebhookGenericWebServiceSecretVersionsForRequestHeader',
     'CxWebhookServiceDirectory',
     'CxWebhookServiceDirectoryGenericWebService',
+    'CxWebhookServiceDirectoryGenericWebServiceOauthConfig',
+    'CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader',
     'EncryptionSpecEncryptionSpec',
     'EntityTypeEntity',
     'FulfillmentFeature',
@@ -4273,6 +4281,188 @@ class CxGenerativeSettingsLlmModelSettings(dict):
         return pulumi.get(self, "prompt_text")
 
 
+@pulumi.output_type
+class CxGeneratorLlmModelSettings(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "promptText":
+            suggest = "prompt_text"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CxGeneratorLlmModelSettings. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CxGeneratorLlmModelSettings.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CxGeneratorLlmModelSettings.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 model: Optional[_builtins.str] = None,
+                 prompt_text: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str model: The selected LLM model.
+        :param _builtins.str prompt_text: The custom prompt to use.
+        """
+        if model is not None:
+            pulumi.set(__self__, "model", model)
+        if prompt_text is not None:
+            pulumi.set(__self__, "prompt_text", prompt_text)
+
+    @_builtins.property
+    @pulumi.getter
+    def model(self) -> Optional[_builtins.str]:
+        """
+        The selected LLM model.
+        """
+        return pulumi.get(self, "model")
+
+    @_builtins.property
+    @pulumi.getter(name="promptText")
+    def prompt_text(self) -> Optional[_builtins.str]:
+        """
+        The custom prompt to use.
+        """
+        return pulumi.get(self, "prompt_text")
+
+
+@pulumi.output_type
+class CxGeneratorModelParameter(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxDecodeSteps":
+            suggest = "max_decode_steps"
+        elif key == "topK":
+            suggest = "top_k"
+        elif key == "topP":
+            suggest = "top_p"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CxGeneratorModelParameter. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CxGeneratorModelParameter.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CxGeneratorModelParameter.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_decode_steps: Optional[_builtins.int] = None,
+                 temperature: Optional[_builtins.float] = None,
+                 top_k: Optional[_builtins.int] = None,
+                 top_p: Optional[_builtins.float] = None):
+        """
+        :param _builtins.int max_decode_steps: The maximum number of tokens to generate.
+        :param _builtins.float temperature: The temperature used for sampling. Temperature sampling occurs after both topP and topK have been applied.
+               Valid range: [0.0, 1.0] Low temperature = less random. High temperature = more random.
+        :param _builtins.int top_k: If set, the sampling process in each step is limited to the topK tokens with highest probabilities.
+               Valid range: [1, 40] or 1000+. Small topK = less random. Large topK = more random.
+        :param _builtins.float top_p: If set, only the tokens comprising the top topP probability mass are considered.
+               If both topP and topK are set, topP will be used for further refining candidates selected with topK.
+               Valid range: (0.0, 1.0]. Small topP = less random. Large topP = more random.
+        """
+        if max_decode_steps is not None:
+            pulumi.set(__self__, "max_decode_steps", max_decode_steps)
+        if temperature is not None:
+            pulumi.set(__self__, "temperature", temperature)
+        if top_k is not None:
+            pulumi.set(__self__, "top_k", top_k)
+        if top_p is not None:
+            pulumi.set(__self__, "top_p", top_p)
+
+    @_builtins.property
+    @pulumi.getter(name="maxDecodeSteps")
+    def max_decode_steps(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of tokens to generate.
+        """
+        return pulumi.get(self, "max_decode_steps")
+
+    @_builtins.property
+    @pulumi.getter
+    def temperature(self) -> Optional[_builtins.float]:
+        """
+        The temperature used for sampling. Temperature sampling occurs after both topP and topK have been applied.
+        Valid range: [0.0, 1.0] Low temperature = less random. High temperature = more random.
+        """
+        return pulumi.get(self, "temperature")
+
+    @_builtins.property
+    @pulumi.getter(name="topK")
+    def top_k(self) -> Optional[_builtins.int]:
+        """
+        If set, the sampling process in each step is limited to the topK tokens with highest probabilities.
+        Valid range: [1, 40] or 1000+. Small topK = less random. Large topK = more random.
+        """
+        return pulumi.get(self, "top_k")
+
+    @_builtins.property
+    @pulumi.getter(name="topP")
+    def top_p(self) -> Optional[_builtins.float]:
+        """
+        If set, only the tokens comprising the top topP probability mass are considered.
+        If both topP and topK are set, topP will be used for further refining candidates selected with topK.
+        Valid range: (0.0, 1.0]. Small topP = less random. Large topP = more random.
+        """
+        return pulumi.get(self, "top_p")
+
+
+@pulumi.output_type
+class CxGeneratorPlaceholder(dict):
+    def __init__(__self__, *,
+                 id: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str id: Unique ID used to map custom placeholder to parameters in fulfillment.
+        :param _builtins.str name: Custom placeholder value in the prompt text.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.str]:
+        """
+        Unique ID used to map custom placeholder to parameters in fulfillment.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        Custom placeholder value in the prompt text.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class CxGeneratorPromptText(dict):
+    def __init__(__self__, *,
+                 text: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str text: Text input which can be used for prompt or banned phrases.
+        """
+        if text is not None:
+            pulumi.set(__self__, "text", text)
+
+    @_builtins.property
+    @pulumi.getter
+    def text(self) -> Optional[_builtins.str]:
+        """
+        Text input which can be used for prompt or banned phrases.
+        """
+        return pulumi.get(self, "text")
+
+
 @pulumi.output_type
 class CxIntentParameter(dict):
     @staticmethod
@@ -11630,8 +11820,24 @@ class CxWebhookGenericWebService(dict):
         suggest = None
         if key == "allowedCaCerts":
             suggest = "allowed_ca_certs"
+        elif key == "httpMethod":
+            suggest = "http_method"
+        elif key == "oauthConfig":
+            suggest = "oauth_config"
+        elif key == "parameterMapping":
+            suggest = "parameter_mapping"
+        elif key == "requestBody":
+            suggest = "request_body"
         elif key == "requestHeaders":
             suggest = "request_headers"
+        elif key == "secretVersionForUsernamePassword":
+            suggest = "secret_version_for_username_password"
+        elif key == "secretVersionsForRequestHeaders":
+            suggest = "secret_versions_for_request_headers"
+        elif key == "serviceAgentAuth":
+            suggest = "service_agent_auth"
+        elif key == "webhookType":
+            suggest = "webhook_type"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in CxWebhookGenericWebService. Access the value via the '{suggest}' property getter instead.")
@@ -11647,23 +11853,83 @@ class CxWebhookGenericWebService(dict):
     def __init__(__self__, *,
                  uri: _builtins.str,
                  allowed_ca_certs: Optional[Sequence[_builtins.str]] = None,
-                 request_headers: Optional[Mapping[str, _builtins.str]] = None):
-        """
-        :param _builtins.str uri: Whether to use speech adaptation for speech recognition.
-        :param Sequence[_builtins.str] allowed_ca_certs: Specifies a list of allowed custom CA certificates (in DER format) for HTTPS verification.
+                 http_method: Optional[_builtins.str] = None,
+                 oauth_config: Optional['outputs.CxWebhookGenericWebServiceOauthConfig'] = None,
+                 parameter_mapping: Optional[Mapping[str, _builtins.str]] = None,
+                 request_body: Optional[_builtins.str] = None,
+                 request_headers: Optional[Mapping[str, _builtins.str]] = None,
+                 secret_version_for_username_password: Optional[_builtins.str] = None,
+                 secret_versions_for_request_headers: Optional[Sequence['outputs.CxWebhookGenericWebServiceSecretVersionsForRequestHeader']] = None,
+                 service_agent_auth: Optional[_builtins.str] = None,
+                 webhook_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str uri: The webhook URI for receiving POST requests. It must use https protocol.
+        :param Sequence[_builtins.str] allowed_ca_certs: Specifies a list of allowed custom CA certificates (in DER format) for
+               HTTPS verification. This overrides the default SSL trust store. If this
+               is empty or unspecified, Dialogflow will use Google's default trust store
+               to verify certificates.
+               N.B. Make sure the HTTPS server certificates are signed with "subject alt
+               name". For instance a certificate can be self-signed using the following
+               command,
+               openssl x509 -req -days 200 -in example.com.csr \\
+               -signkey example.com.key \\
+               -out example.com.crt \\
+               -extfile <(printf "\\nsubjectAltName='DNS:www.example.com'")
+        :param _builtins.str http_method: HTTP method for the flexible webhook calls. Standard webhook always uses
+               POST.
+               Possible values are: `POST`, `GET`, `HEAD`, `PUT`, `DELETE`, `PATCH`, `OPTIONS`.
+        :param 'CxWebhookGenericWebServiceOauthConfigArgs' oauth_config: Represents configuration of OAuth client credential flow for 3rd party
+               API authentication.
+               Structure is documented below.
+        :param Mapping[str, _builtins.str] parameter_mapping: Maps the values extracted from specific fields of the flexible webhook
+               response into session parameters.
+               - Key: session parameter name
+               - Value: field path in the webhook response
+        :param _builtins.str request_body: Defines a custom JSON object as request body to send to flexible webhook.
         :param Mapping[str, _builtins.str] request_headers: The HTTP request headers to send together with webhook requests.
+        :param _builtins.str secret_version_for_username_password: The SecretManager secret version resource storing the username:password
+               pair for HTTP Basic authentication.
+               Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        :param Sequence['CxWebhookGenericWebServiceSecretVersionsForRequestHeaderArgs'] secret_versions_for_request_headers: The HTTP request headers to send together with webhook requests. Header
+               values are stored in SecretManager secret versions.
+               When the same header name is specified in both `request_headers` and
+               `secret_versions_for_request_headers`, the value in
+               `secret_versions_for_request_headers` will be used.
+               Structure is documented below.
+        :param _builtins.str service_agent_auth: Indicate the auth token type generated from the [Diglogflow service
+               agent](https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent).
+               The generated token is sent in the Authorization header.
+               Possible values are: `NONE`, `ID_TOKEN`, `ACCESS_TOKEN`.
+        :param _builtins.str webhook_type: Type of the webhook.
+               Possible values are: `STANDARD`, `FLEXIBLE`.
         """
         pulumi.set(__self__, "uri", uri)
         if allowed_ca_certs is not None:
             pulumi.set(__self__, "allowed_ca_certs", allowed_ca_certs)
+        if http_method is not None:
+            pulumi.set(__self__, "http_method", http_method)
+        if oauth_config is not None:
+            pulumi.set(__self__, "oauth_config", oauth_config)
+        if parameter_mapping is not None:
+            pulumi.set(__self__, "parameter_mapping", parameter_mapping)
+        if request_body is not None:
+            pulumi.set(__self__, "request_body", request_body)
         if request_headers is not None:
             pulumi.set(__self__, "request_headers", request_headers)
+        if secret_version_for_username_password is not None:
+            pulumi.set(__self__, "secret_version_for_username_password", secret_version_for_username_password)
+        if secret_versions_for_request_headers is not None:
+            pulumi.set(__self__, "secret_versions_for_request_headers", secret_versions_for_request_headers)
+        if service_agent_auth is not None:
+            pulumi.set(__self__, "service_agent_auth", service_agent_auth)
+        if webhook_type is not None:
+            pulumi.set(__self__, "webhook_type", webhook_type)
 
     @_builtins.property
     @pulumi.getter
     def uri(self) -> _builtins.str:
         """
-        Whether to use speech adaptation for speech recognition.
+        The webhook URI for receiving POST requests. It must use https protocol.
         """
         return pulumi.get(self, "uri")
 
@@ -11671,10 +11937,59 @@ class CxWebhookGenericWebService(dict):
     @pulumi.getter(name="allowedCaCerts")
     def allowed_ca_certs(self) -> Optional[Sequence[_builtins.str]]:
         """
-        Specifies a list of allowed custom CA certificates (in DER format) for HTTPS verification.
+        Specifies a list of allowed custom CA certificates (in DER format) for
+        HTTPS verification. This overrides the default SSL trust store. If this
+        is empty or unspecified, Dialogflow will use Google's default trust store
+        to verify certificates.
+        N.B. Make sure the HTTPS server certificates are signed with "subject alt
+        name". For instance a certificate can be self-signed using the following
+        command,
+        openssl x509 -req -days 200 -in example.com.csr \\
+        -signkey example.com.key \\
+        -out example.com.crt \\
+        -extfile <(printf "\\nsubjectAltName='DNS:www.example.com'")
         """
         return pulumi.get(self, "allowed_ca_certs")
 
+    @_builtins.property
+    @pulumi.getter(name="httpMethod")
+    def http_method(self) -> Optional[_builtins.str]:
+        """
+        HTTP method for the flexible webhook calls. Standard webhook always uses
+        POST.
+        Possible values are: `POST`, `GET`, `HEAD`, `PUT`, `DELETE`, `PATCH`, `OPTIONS`.
+        """
+        return pulumi.get(self, "http_method")
+
+    @_builtins.property
+    @pulumi.getter(name="oauthConfig")
+    def oauth_config(self) -> Optional['outputs.CxWebhookGenericWebServiceOauthConfig']:
+        """
+        Represents configuration of OAuth client credential flow for 3rd party
+        API authentication.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "oauth_config")
+
+    @_builtins.property
+    @pulumi.getter(name="parameterMapping")
+    def parameter_mapping(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        Maps the values extracted from specific fields of the flexible webhook
+        response into session parameters.
+        - Key: session parameter name
+        - Value: field path in the webhook response
+        """
+        return pulumi.get(self, "parameter_mapping")
+
+    @_builtins.property
+    @pulumi.getter(name="requestBody")
+    def request_body(self) -> Optional[_builtins.str]:
+        """
+        Defines a custom JSON object as request body to send to flexible webhook.
+        """
+        return pulumi.get(self, "request_body")
+
     @_builtins.property
     @pulumi.getter(name="requestHeaders")
     def request_headers(self) -> Optional[Mapping[str, _builtins.str]]:
@@ -11683,6 +11998,197 @@ class CxWebhookGenericWebService(dict):
         """
         return pulumi.get(self, "request_headers")
 
+    @_builtins.property
+    @pulumi.getter(name="secretVersionForUsernamePassword")
+    def secret_version_for_username_password(self) -> Optional[_builtins.str]:
+        """
+        The SecretManager secret version resource storing the username:password
+        pair for HTTP Basic authentication.
+        Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        return pulumi.get(self, "secret_version_for_username_password")
+
+    @_builtins.property
+    @pulumi.getter(name="secretVersionsForRequestHeaders")
+    def secret_versions_for_request_headers(self) -> Optional[Sequence['outputs.CxWebhookGenericWebServiceSecretVersionsForRequestHeader']]:
+        """
+        The HTTP request headers to send together with webhook requests. Header
+        values are stored in SecretManager secret versions.
+        When the same header name is specified in both `request_headers` and
+        `secret_versions_for_request_headers`, the value in
+        `secret_versions_for_request_headers` will be used.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "secret_versions_for_request_headers")
+
+    @_builtins.property
+    @pulumi.getter(name="serviceAgentAuth")
+    def service_agent_auth(self) -> Optional[_builtins.str]:
+        """
+        Indicate the auth token type generated from the [Diglogflow service
+        agent](https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent).
+        The generated token is sent in the Authorization header.
+        Possible values are: `NONE`, `ID_TOKEN`, `ACCESS_TOKEN`.
+        """
+        return pulumi.get(self, "service_agent_auth")
+
+    @_builtins.property
+    @pulumi.getter(name="webhookType")
+    def webhook_type(self) -> Optional[_builtins.str]:
+        """
+        Type of the webhook.
+        Possible values are: `STANDARD`, `FLEXIBLE`.
+        """
+        return pulumi.get(self, "webhook_type")
+
+
+@pulumi.output_type
+class CxWebhookGenericWebServiceOauthConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "tokenEndpoint":
+            suggest = "token_endpoint"
+        elif key == "clientSecret":
+            suggest = "client_secret"
+        elif key == "secretVersionForClientSecret":
+            suggest = "secret_version_for_client_secret"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CxWebhookGenericWebServiceOauthConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CxWebhookGenericWebServiceOauthConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CxWebhookGenericWebServiceOauthConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: _builtins.str,
+                 token_endpoint: _builtins.str,
+                 client_secret: Optional[_builtins.str] = None,
+                 scopes: Optional[Sequence[_builtins.str]] = None,
+                 secret_version_for_client_secret: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str client_id: The client ID provided by the 3rd party platform.
+        :param _builtins.str token_endpoint: The token endpoint provided by the 3rd party platform to exchange an
+               access token.
+        :param _builtins.str client_secret: The client secret provided by the 3rd party platform.  If the
+               `secret_version_for_client_secret` field is set, this field will be
+               ignored.
+        :param Sequence[_builtins.str] scopes: The OAuth scopes to grant.
+        :param _builtins.str secret_version_for_client_secret: The name of the SecretManager secret version resource storing the
+               client secret. If this field is set, the `client_secret` field will be
+               ignored.
+               Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "token_endpoint", token_endpoint)
+        if client_secret is not None:
+            pulumi.set(__self__, "client_secret", client_secret)
+        if scopes is not None:
+            pulumi.set(__self__, "scopes", scopes)
+        if secret_version_for_client_secret is not None:
+            pulumi.set(__self__, "secret_version_for_client_secret", secret_version_for_client_secret)
+
+    @_builtins.property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> _builtins.str:
+        """
+        The client ID provided by the 3rd party platform.
+        """
+        return pulumi.get(self, "client_id")
+
+    @_builtins.property
+    @pulumi.getter(name="tokenEndpoint")
+    def token_endpoint(self) -> _builtins.str:
+        """
+        The token endpoint provided by the 3rd party platform to exchange an
+        access token.
+        """
+        return pulumi.get(self, "token_endpoint")
+
+    @_builtins.property
+    @pulumi.getter(name="clientSecret")
+    def client_secret(self) -> Optional[_builtins.str]:
+        """
+        The client secret provided by the 3rd party platform.  If the
+        `secret_version_for_client_secret` field is set, this field will be
+        ignored.
+        """
+        return pulumi.get(self, "client_secret")
+
+    @_builtins.property
+    @pulumi.getter
+    def scopes(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The OAuth scopes to grant.
+        """
+        return pulumi.get(self, "scopes")
+
+    @_builtins.property
+    @pulumi.getter(name="secretVersionForClientSecret")
+    def secret_version_for_client_secret(self) -> Optional[_builtins.str]:
+        """
+        The name of the SecretManager secret version resource storing the
+        client secret. If this field is set, the `client_secret` field will be
+        ignored.
+        Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        return pulumi.get(self, "secret_version_for_client_secret")
+
+
+@pulumi.output_type
+class CxWebhookGenericWebServiceSecretVersionsForRequestHeader(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "secretVersion":
+            suggest = "secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CxWebhookGenericWebServiceSecretVersionsForRequestHeader. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CxWebhookGenericWebServiceSecretVersionsForRequestHeader.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CxWebhookGenericWebServiceSecretVersionsForRequestHeader.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key: _builtins.str,
+                 secret_version: _builtins.str):
+        """
+        :param _builtins.str key: The identifier for this object. Format specified above.
+        :param _builtins.str secret_version: The SecretManager secret version resource storing the header value.
+               Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "secret_version", secret_version)
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> _builtins.str:
+        """
+        The identifier for this object. Format specified above.
+        """
+        return pulumi.get(self, "key")
+
+    @_builtins.property
+    @pulumi.getter(name="secretVersion")
+    def secret_version(self) -> _builtins.str:
+        """
+        The SecretManager secret version resource storing the header value.
+        Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        return pulumi.get(self, "secret_version")
+
 
 @pulumi.output_type
 class CxWebhookServiceDirectory(dict):
@@ -11704,32 +12210,33 @@ class CxWebhookServiceDirectory(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 generic_web_service: 'outputs.CxWebhookServiceDirectoryGenericWebService',
-                 service: _builtins.str):
+                 service: _builtins.str,
+                 generic_web_service: Optional['outputs.CxWebhookServiceDirectoryGenericWebService'] = None):
         """
-        :param 'CxWebhookServiceDirectoryGenericWebServiceArgs' generic_web_service: The name of Service Directory service.
-               Structure is documented below.
         :param _builtins.str service: The name of Service Directory service.
+        :param 'CxWebhookServiceDirectoryGenericWebServiceArgs' generic_web_service: Represents configuration for a generic web service.
+               Structure is documented below.
         """
-        pulumi.set(__self__, "generic_web_service", generic_web_service)
         pulumi.set(__self__, "service", service)
+        if generic_web_service is not None:
+            pulumi.set(__self__, "generic_web_service", generic_web_service)
 
     @_builtins.property
-    @pulumi.getter(name="genericWebService")
-    def generic_web_service(self) -> 'outputs.CxWebhookServiceDirectoryGenericWebService':
+    @pulumi.getter
+    def service(self) -> _builtins.str:
         """
         The name of Service Directory service.
-        Structure is documented below.
         """
-        return pulumi.get(self, "generic_web_service")
+        return pulumi.get(self, "service")
 
     @_builtins.property
-    @pulumi.getter
-    def service(self) -> _builtins.str:
+    @pulumi.getter(name="genericWebService")
+    def generic_web_service(self) -> Optional['outputs.CxWebhookServiceDirectoryGenericWebService']:
         """
-        The name of Service Directory service.
+        Represents configuration for a generic web service.
+        Structure is documented below.
         """
-        return pulumi.get(self, "service")
+        return pulumi.get(self, "generic_web_service")
 
 
 @pulumi.output_type
@@ -11739,8 +12246,24 @@ class CxWebhookServiceDirectoryGenericWebService(dict):
         suggest = None
         if key == "allowedCaCerts":
             suggest = "allowed_ca_certs"
+        elif key == "httpMethod":
+            suggest = "http_method"
+        elif key == "oauthConfig":
+            suggest = "oauth_config"
+        elif key == "parameterMapping":
+            suggest = "parameter_mapping"
+        elif key == "requestBody":
+            suggest = "request_body"
         elif key == "requestHeaders":
             suggest = "request_headers"
+        elif key == "secretVersionForUsernamePassword":
+            suggest = "secret_version_for_username_password"
+        elif key == "secretVersionsForRequestHeaders":
+            suggest = "secret_versions_for_request_headers"
+        elif key == "serviceAgentAuth":
+            suggest = "service_agent_auth"
+        elif key == "webhookType":
+            suggest = "webhook_type"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in CxWebhookServiceDirectoryGenericWebService. Access the value via the '{suggest}' property getter instead.")
@@ -11756,23 +12279,83 @@ class CxWebhookServiceDirectoryGenericWebService(dict):
     def __init__(__self__, *,
                  uri: _builtins.str,
                  allowed_ca_certs: Optional[Sequence[_builtins.str]] = None,
-                 request_headers: Optional[Mapping[str, _builtins.str]] = None):
-        """
-        :param _builtins.str uri: Whether to use speech adaptation for speech recognition.
-        :param Sequence[_builtins.str] allowed_ca_certs: Specifies a list of allowed custom CA certificates (in DER format) for HTTPS verification.
+                 http_method: Optional[_builtins.str] = None,
+                 oauth_config: Optional['outputs.CxWebhookServiceDirectoryGenericWebServiceOauthConfig'] = None,
+                 parameter_mapping: Optional[Mapping[str, _builtins.str]] = None,
+                 request_body: Optional[_builtins.str] = None,
+                 request_headers: Optional[Mapping[str, _builtins.str]] = None,
+                 secret_version_for_username_password: Optional[_builtins.str] = None,
+                 secret_versions_for_request_headers: Optional[Sequence['outputs.CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader']] = None,
+                 service_agent_auth: Optional[_builtins.str] = None,
+                 webhook_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str uri: The webhook URI for receiving POST requests. It must use https protocol.
+        :param Sequence[_builtins.str] allowed_ca_certs: Specifies a list of allowed custom CA certificates (in DER format) for
+               HTTPS verification. This overrides the default SSL trust store. If this
+               is empty or unspecified, Dialogflow will use Google's default trust store
+               to verify certificates.
+               N.B. Make sure the HTTPS server certificates are signed with "subject alt
+               name". For instance a certificate can be self-signed using the following
+               command,
+               openssl x509 -req -days 200 -in example.com.csr \\
+               -signkey example.com.key \\
+               -out example.com.crt \\
+               -extfile <(printf "\\nsubjectAltName='DNS:www.example.com'")
+        :param _builtins.str http_method: HTTP method for the flexible webhook calls. Standard webhook always uses
+               POST.
+               Possible values are: `POST`, `GET`, `HEAD`, `PUT`, `DELETE`, `PATCH`, `OPTIONS`.
+        :param 'CxWebhookServiceDirectoryGenericWebServiceOauthConfigArgs' oauth_config: Represents configuration of OAuth client credential flow for 3rd party
+               API authentication.
+               Structure is documented below.
+        :param Mapping[str, _builtins.str] parameter_mapping: Maps the values extracted from specific fields of the flexible webhook
+               response into session parameters.
+               - Key: session parameter name
+               - Value: field path in the webhook response
+        :param _builtins.str request_body: Defines a custom JSON object as request body to send to flexible webhook.
         :param Mapping[str, _builtins.str] request_headers: The HTTP request headers to send together with webhook requests.
+        :param _builtins.str secret_version_for_username_password: The SecretManager secret version resource storing the username:password
+               pair for HTTP Basic authentication.
+               Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        :param Sequence['CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeaderArgs'] secret_versions_for_request_headers: The HTTP request headers to send together with webhook requests. Header
+               values are stored in SecretManager secret versions.
+               When the same header name is specified in both `request_headers` and
+               `secret_versions_for_request_headers`, the value in
+               `secret_versions_for_request_headers` will be used.
+               Structure is documented below.
+        :param _builtins.str service_agent_auth: Indicate the auth token type generated from the [Diglogflow service
+               agent](https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent).
+               The generated token is sent in the Authorization header.
+               Possible values are: `NONE`, `ID_TOKEN`, `ACCESS_TOKEN`.
+        :param _builtins.str webhook_type: Type of the webhook.
+               Possible values are: `STANDARD`, `FLEXIBLE`.
         """
         pulumi.set(__self__, "uri", uri)
         if allowed_ca_certs is not None:
             pulumi.set(__self__, "allowed_ca_certs", allowed_ca_certs)
+        if http_method is not None:
+            pulumi.set(__self__, "http_method", http_method)
+        if oauth_config is not None:
+            pulumi.set(__self__, "oauth_config", oauth_config)
+        if parameter_mapping is not None:
+            pulumi.set(__self__, "parameter_mapping", parameter_mapping)
+        if request_body is not None:
+            pulumi.set(__self__, "request_body", request_body)
         if request_headers is not None:
             pulumi.set(__self__, "request_headers", request_headers)
+        if secret_version_for_username_password is not None:
+            pulumi.set(__self__, "secret_version_for_username_password", secret_version_for_username_password)
+        if secret_versions_for_request_headers is not None:
+            pulumi.set(__self__, "secret_versions_for_request_headers", secret_versions_for_request_headers)
+        if service_agent_auth is not None:
+            pulumi.set(__self__, "service_agent_auth", service_agent_auth)
+        if webhook_type is not None:
+            pulumi.set(__self__, "webhook_type", webhook_type)
 
     @_builtins.property
     @pulumi.getter
     def uri(self) -> _builtins.str:
         """
-        Whether to use speech adaptation for speech recognition.
+        The webhook URI for receiving POST requests. It must use https protocol.
         """
         return pulumi.get(self, "uri")
 
@@ -11780,10 +12363,59 @@ class CxWebhookServiceDirectoryGenericWebService(dict):
     @pulumi.getter(name="allowedCaCerts")
     def allowed_ca_certs(self) -> Optional[Sequence[_builtins.str]]:
         """
-        Specifies a list of allowed custom CA certificates (in DER format) for HTTPS verification.
+        Specifies a list of allowed custom CA certificates (in DER format) for
+        HTTPS verification. This overrides the default SSL trust store. If this
+        is empty or unspecified, Dialogflow will use Google's default trust store
+        to verify certificates.
+        N.B. Make sure the HTTPS server certificates are signed with "subject alt
+        name". For instance a certificate can be self-signed using the following
+        command,
+        openssl x509 -req -days 200 -in example.com.csr \\
+        -signkey example.com.key \\
+        -out example.com.crt \\
+        -extfile <(printf "\\nsubjectAltName='DNS:www.example.com'")
         """
         return pulumi.get(self, "allowed_ca_certs")
 
+    @_builtins.property
+    @pulumi.getter(name="httpMethod")
+    def http_method(self) -> Optional[_builtins.str]:
+        """
+        HTTP method for the flexible webhook calls. Standard webhook always uses
+        POST.
+        Possible values are: `POST`, `GET`, `HEAD`, `PUT`, `DELETE`, `PATCH`, `OPTIONS`.
+        """
+        return pulumi.get(self, "http_method")
+
+    @_builtins.property
+    @pulumi.getter(name="oauthConfig")
+    def oauth_config(self) -> Optional['outputs.CxWebhookServiceDirectoryGenericWebServiceOauthConfig']:
+        """
+        Represents configuration of OAuth client credential flow for 3rd party
+        API authentication.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "oauth_config")
+
+    @_builtins.property
+    @pulumi.getter(name="parameterMapping")
+    def parameter_mapping(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        Maps the values extracted from specific fields of the flexible webhook
+        response into session parameters.
+        - Key: session parameter name
+        - Value: field path in the webhook response
+        """
+        return pulumi.get(self, "parameter_mapping")
+
+    @_builtins.property
+    @pulumi.getter(name="requestBody")
+    def request_body(self) -> Optional[_builtins.str]:
+        """
+        Defines a custom JSON object as request body to send to flexible webhook.
+        """
+        return pulumi.get(self, "request_body")
+
     @_builtins.property
     @pulumi.getter(name="requestHeaders")
     def request_headers(self) -> Optional[Mapping[str, _builtins.str]]:
@@ -11792,6 +12424,197 @@ class CxWebhookServiceDirectoryGenericWebService(dict):
         """
         return pulumi.get(self, "request_headers")
 
+    @_builtins.property
+    @pulumi.getter(name="secretVersionForUsernamePassword")
+    def secret_version_for_username_password(self) -> Optional[_builtins.str]:
+        """
+        The SecretManager secret version resource storing the username:password
+        pair for HTTP Basic authentication.
+        Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        return pulumi.get(self, "secret_version_for_username_password")
+
+    @_builtins.property
+    @pulumi.getter(name="secretVersionsForRequestHeaders")
+    def secret_versions_for_request_headers(self) -> Optional[Sequence['outputs.CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader']]:
+        """
+        The HTTP request headers to send together with webhook requests. Header
+        values are stored in SecretManager secret versions.
+        When the same header name is specified in both `request_headers` and
+        `secret_versions_for_request_headers`, the value in
+        `secret_versions_for_request_headers` will be used.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "secret_versions_for_request_headers")
+
+    @_builtins.property
+    @pulumi.getter(name="serviceAgentAuth")
+    def service_agent_auth(self) -> Optional[_builtins.str]:
+        """
+        Indicate the auth token type generated from the [Diglogflow service
+        agent](https://cloud.google.com/iam/docs/service-agents#dialogflow-service-agent).
+        The generated token is sent in the Authorization header.
+        Possible values are: `NONE`, `ID_TOKEN`, `ACCESS_TOKEN`.
+        """
+        return pulumi.get(self, "service_agent_auth")
+
+    @_builtins.property
+    @pulumi.getter(name="webhookType")
+    def webhook_type(self) -> Optional[_builtins.str]:
+        """
+        Type of the webhook.
+        Possible values are: `STANDARD`, `FLEXIBLE`.
+        """
+        return pulumi.get(self, "webhook_type")
+
+
+@pulumi.output_type
+class CxWebhookServiceDirectoryGenericWebServiceOauthConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "tokenEndpoint":
+            suggest = "token_endpoint"
+        elif key == "clientSecret":
+            suggest = "client_secret"
+        elif key == "secretVersionForClientSecret":
+            suggest = "secret_version_for_client_secret"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CxWebhookServiceDirectoryGenericWebServiceOauthConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CxWebhookServiceDirectoryGenericWebServiceOauthConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CxWebhookServiceDirectoryGenericWebServiceOauthConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: _builtins.str,
+                 token_endpoint: _builtins.str,
+                 client_secret: Optional[_builtins.str] = None,
+                 scopes: Optional[Sequence[_builtins.str]] = None,
+                 secret_version_for_client_secret: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str client_id: The client ID provided by the 3rd party platform.
+        :param _builtins.str token_endpoint: The token endpoint provided by the 3rd party platform to exchange an
+               access token.
+        :param _builtins.str client_secret: The client secret provided by the 3rd party platform.  If the
+               `secret_version_for_client_secret` field is set, this field will be
+               ignored.
+        :param Sequence[_builtins.str] scopes: The OAuth scopes to grant.
+        :param _builtins.str secret_version_for_client_secret: The name of the SecretManager secret version resource storing the
+               client secret. If this field is set, the `client_secret` field will be
+               ignored.
+               Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "token_endpoint", token_endpoint)
+        if client_secret is not None:
+            pulumi.set(__self__, "client_secret", client_secret)
+        if scopes is not None:
+            pulumi.set(__self__, "scopes", scopes)
+        if secret_version_for_client_secret is not None:
+            pulumi.set(__self__, "secret_version_for_client_secret", secret_version_for_client_secret)
+
+    @_builtins.property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> _builtins.str:
+        """
+        The client ID provided by the 3rd party platform.
+        """
+        return pulumi.get(self, "client_id")
+
+    @_builtins.property
+    @pulumi.getter(name="tokenEndpoint")
+    def token_endpoint(self) -> _builtins.str:
+        """
+        The token endpoint provided by the 3rd party platform to exchange an
+        access token.
+        """
+        return pulumi.get(self, "token_endpoint")
+
+    @_builtins.property
+    @pulumi.getter(name="clientSecret")
+    def client_secret(self) -> Optional[_builtins.str]:
+        """
+        The client secret provided by the 3rd party platform.  If the
+        `secret_version_for_client_secret` field is set, this field will be
+        ignored.
+        """
+        return pulumi.get(self, "client_secret")
+
+    @_builtins.property
+    @pulumi.getter
+    def scopes(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The OAuth scopes to grant.
+        """
+        return pulumi.get(self, "scopes")
+
+    @_builtins.property
+    @pulumi.getter(name="secretVersionForClientSecret")
+    def secret_version_for_client_secret(self) -> Optional[_builtins.str]:
+        """
+        The name of the SecretManager secret version resource storing the
+        client secret. If this field is set, the `client_secret` field will be
+        ignored.
+        Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        return pulumi.get(self, "secret_version_for_client_secret")
+
+
+@pulumi.output_type
+class CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "secretVersion":
+            suggest = "secret_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CxWebhookServiceDirectoryGenericWebServiceSecretVersionsForRequestHeader.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key: _builtins.str,
+                 secret_version: _builtins.str):
+        """
+        :param _builtins.str key: The identifier for this object. Format specified above.
+        :param _builtins.str secret_version: The SecretManager secret version resource storing the header value.
+               Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "secret_version", secret_version)
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> _builtins.str:
+        """
+        The identifier for this object. Format specified above.
+        """
+        return pulumi.get(self, "key")
+
+    @_builtins.property
+    @pulumi.getter(name="secretVersion")
+    def secret_version(self) -> _builtins.str:
+        """
+        The SecretManager secret version resource storing the header value.
+        Format: `projects/{project}/secrets/{secret}/versions/{version}`
+        """
+        return pulumi.get(self, "secret_version")
+
 
 @pulumi.output_type
 class EncryptionSpecEncryptionSpec(dict):