create_message_template async ¶

async def create_message_template(
    self,
    knowledge_base_id: "capo_qconnect.types.uuid_or_arn.UuidOrArn",
    channel_subtype: "capo_qconnect.types.channel_subtype.ChannelSubtype",
    *,
    config_overrides: Optional[AsyncQConnectClientConfig] = None,
    name: Optional["capo_qconnect.types.name.Name"] = None,
    content: Optional[
        "capo_qconnect.types.message_template_content_provider.MessageTemplateContentProvider"
    ] = None,
    description: Optional["capo_qconnect.types.description.Description"] = None,
    language: Optional["capo_qconnect.types.language_code.LanguageCode"] = None,
    source_configuration: Optional[
        "capo_qconnect.types.message_template_source_configuration.MessageTemplateSourceConfiguration"
    ] = None,
    default_attributes: Optional[
        "capo_qconnect.types.message_template_attributes.MessageTemplateAttributes"
    ] = None,
    grouping_configuration: Optional[
        "capo_qconnect.types.grouping_configuration.GroupingConfiguration"
    ] = None,
    client_token: Optional["capo_qconnect.types.client_token.ClientToken"] = None,
    tags: Optional["capo_qconnect.types.tags.Tags"] = None,
) -> "capo_qconnect.types.create_message_template_response.CreateMessageTemplateResponse":
    """<p>Creates an Amazon Q in Connect message template. The name of the message template has to be unique for each knowledge base. The channel subtype of the message template is immutable and cannot be modified after creation. After the message template is created, you can use the <code>$LATEST</code> qualifier to reference the created message template.</p>

    Args:
        knowledge_base_id: <p>The identifier of the knowledge base. Can be either the ID or the ARN. URLs cannot contain the ARN.</p>
        name: <p>The name of the message template.</p>
        content: <p>The content of the message template.</p>
        description: <p>The description of the message template.</p>
        channel_subtype: <p>The channel subtype this message template applies to.</p>
        language: <p>The language code value for the language in which the quick response is written. The supported language codes include <code>de_DE</code>, <code>en_US</code>, <code>es_ES</code>, <code>fr_FR</code>, <code>id_ID</code>, <code>it_IT</code>, <code>ja_JP</code>, <code>ko_KR</code>, <code>pt_BR</code>, <code>zh_CN</code>, <code>zh_TW</code> </p>
        source_configuration: <p>The source configuration of the message template. Only set this argument for WHATSAPP channel subtype.</p>
        default_attributes: <p>An object that specifies the default values to use for variables in the message template. This object contains different categories of key-value pairs. Each key defines a variable or placeholder in the message template. The corresponding value defines the default value for that variable.</p>
        client_token: <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see <a href="http://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/">Making retries safe with idempotent APIs</a>.</p>
        tags: <p>The tags used to organize, track, or control access for this resource.</p>

    Raises:
        capo_qconnect.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_qconnect.errors.conflict_exception.ConflictException: <p>The request could not be processed because of conflict in the current state of the resource. For example, if you're using a <code>Create</code> API (such as <code>CreateAssistant</code>) that accepts name, a conflicting resource (usually with the same name) is being created or mutated.</p>
        capo_qconnect.errors.resource_not_found_exception.ResourceNotFoundException: <p>The specified resource does not exist.</p>
        capo_qconnect.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>You've exceeded your service quota. To perform the requested action, remove some of the relevant resources, or use service quotas to request a service quota increase.</p>
        capo_qconnect.errors.throttling_exception.ThrottlingException: <p>The throttling limit has been exceeded.</p>
        capo_qconnect.errors.validation_exception.ValidationException: <p>The input fails to satisfy the constraints specified by a service.</p>
        capo_qconnect.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_qconnect.types.create_message_template_request.CreateMessageTemplateRequest]",
    ) -> AsyncOperationResponse[
        "capo_qconnect.types.create_message_template_response.CreateMessageTemplateResponse"
    ]:
        import capo_qconnect._operations.wisdom_service.create_message_template

        (
            output,
            http_response,
        ) = await capo_qconnect._operations.wisdom_service.create_message_template.async_create_message_template(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    def _redact_input(
        input_: "capo_qconnect.types.create_message_template_request.CreateMessageTemplateRequest",
    ) -> dict[str, Any]:
        import capo_qconnect.types.create_message_template_request

        return capo_qconnect.types.create_message_template_request.redact_sensitive(
            input_
        )

    def _redact_output(
        output: "capo_qconnect.types.create_message_template_response.CreateMessageTemplateResponse",
    ) -> dict[str, Any]:
        import capo_qconnect.types.create_message_template_response

        return (
            capo_qconnect.types.create_message_template_response.redact_sensitive(
                output
            )
        )

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging(
            "CreateMessageTemplate",
            redact_input=_redact_input,
            redact_output=_redact_output,
        ),
    )
    input_: capo_qconnect.types.create_message_template_request.CreateMessageTemplateRequest = {
        "knowledge_base_id": knowledge_base_id,
        "channel_subtype": channel_subtype,
    }
    if name is not None:
        input_["name"] = name
    if content is not None:
        input_["content"] = content
    if description is not None:
        input_["description"] = description
    if language is not None:
        input_["language"] = language
    if source_configuration is not None:
        input_["source_configuration"] = source_configuration
    if default_attributes is not None:
        input_["default_attributes"] = default_attributes
    if grouping_configuration is not None:
        input_["grouping_configuration"] = grouping_configuration
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token
    if tags is not None:
        input_["tags"] = tags

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output