# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from ._enums import *

__all__ = [
    'AS2AcknowledgementConnectionSettingsArgs',
    'AS2AgreementContentArgs',
    'AS2EnvelopeSettingsArgs',
    'AS2ErrorSettingsArgs',
    'AS2MdnSettingsArgs',
    'AS2MessageConnectionSettingsArgs',
    'AS2OneWayAgreementArgs',
    'AS2ProtocolSettingsArgs',
    'AS2SecuritySettingsArgs',
    'AS2ValidationSettingsArgs',
    'AgreementContentArgs',
    'B2BPartnerContentArgs',
    'BusinessIdentityArgs',
    'EdifactAcknowledgementSettingsArgs',
    'EdifactAgreementContentArgs',
    'EdifactDelimiterOverrideArgs',
    'EdifactEnvelopeOverrideArgs',
    'EdifactEnvelopeSettingsArgs',
    'EdifactFramingSettingsArgs',
    'EdifactMessageFilterArgs',
    'EdifactMessageIdentifierArgs',
    'EdifactOneWayAgreementArgs',
    'EdifactProcessingSettingsArgs',
    'EdifactProtocolSettingsArgs',
    'EdifactSchemaReferenceArgs',
    'EdifactValidationOverrideArgs',
    'EdifactValidationSettingsArgs',
    'IntegrationAccountSkuArgs',
    'KeyVaultKeyReferenceKeyVaultArgs',
    'KeyVaultKeyReferenceArgs',
    'PartnerContentArgs',
    'X12AcknowledgementSettingsArgs',
    'X12AgreementContentArgs',
    'X12DelimiterOverridesArgs',
    'X12EnvelopeOverrideArgs',
    'X12EnvelopeSettingsArgs',
    'X12FramingSettingsArgs',
    'X12MessageFilterArgs',
    'X12MessageIdentifierArgs',
    'X12OneWayAgreementArgs',
    'X12ProcessingSettingsArgs',
    'X12ProtocolSettingsArgs',
    'X12SchemaReferenceArgs',
    'X12SecuritySettingsArgs',
    'X12ValidationOverrideArgs',
    'X12ValidationSettingsArgs',
]

@pulumi.input_type
class AS2AcknowledgementConnectionSettingsArgs:
    def __init__(__self__, *,
                 ignore_certificate_name_mismatch: Optional[pulumi.Input[bool]] = None,
                 keep_http_connection_alive: Optional[pulumi.Input[bool]] = None,
                 support_http_status_code_continue: Optional[pulumi.Input[bool]] = None,
                 unfold_http_headers: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] ignore_certificate_name_mismatch: The value indicating whether to ignore mismatch in certificate name.
        :param pulumi.Input[bool] keep_http_connection_alive: The value indicating whether to keep the connection alive.
        :param pulumi.Input[bool] support_http_status_code_continue: The value indicating whether to support HTTP status code 'CONTINUE'.
        :param pulumi.Input[bool] unfold_http_headers: The value indicating whether to unfold the HTTP headers.
        """
        if ignore_certificate_name_mismatch is not None:
            pulumi.set(__self__, "ignore_certificate_name_mismatch", ignore_certificate_name_mismatch)
        if keep_http_connection_alive is not None:
            pulumi.set(__self__, "keep_http_connection_alive", keep_http_connection_alive)
        if support_http_status_code_continue is not None:
            pulumi.set(__self__, "support_http_status_code_continue", support_http_status_code_continue)
        if unfold_http_headers is not None:
            pulumi.set(__self__, "unfold_http_headers", unfold_http_headers)

    @property
    @pulumi.getter(name="ignoreCertificateNameMismatch")
    def ignore_certificate_name_mismatch(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to ignore mismatch in certificate name.
        """
        return pulumi.get(self, "ignore_certificate_name_mismatch")

    @ignore_certificate_name_mismatch.setter
    def ignore_certificate_name_mismatch(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_certificate_name_mismatch", value)

    @property
    @pulumi.getter(name="keepHttpConnectionAlive")
    def keep_http_connection_alive(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to keep the connection alive.
        """
        return pulumi.get(self, "keep_http_connection_alive")

    @keep_http_connection_alive.setter
    def keep_http_connection_alive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_http_connection_alive", value)

    @property
    @pulumi.getter(name="supportHttpStatusCodeContinue")
    def support_http_status_code_continue(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to support HTTP status code 'CONTINUE'.
        """
        return pulumi.get(self, "support_http_status_code_continue")

    @support_http_status_code_continue.setter
    def support_http_status_code_continue(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "support_http_status_code_continue", value)

    @property
    @pulumi.getter(name="unfoldHttpHeaders")
    def unfold_http_headers(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to unfold the HTTP headers.
        """
        return pulumi.get(self, "unfold_http_headers")

    @unfold_http_headers.setter
    def unfold_http_headers(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "unfold_http_headers", value)


@pulumi.input_type
class AS2AgreementContentArgs:
    def __init__(__self__, *,
                 receive_agreement: Optional[pulumi.Input['AS2OneWayAgreementArgs']] = None,
                 send_agreement: Optional[pulumi.Input['AS2OneWayAgreementArgs']] = None):
        """
        :param pulumi.Input['AS2OneWayAgreementArgs'] receive_agreement: The AS2 one-way receive agreement.
        :param pulumi.Input['AS2OneWayAgreementArgs'] send_agreement: The AS2 one-way send agreement.
        """
        if receive_agreement is not None:
            pulumi.set(__self__, "receive_agreement", receive_agreement)
        if send_agreement is not None:
            pulumi.set(__self__, "send_agreement", send_agreement)

    @property
    @pulumi.getter(name="receiveAgreement")
    def receive_agreement(self) -> Optional[pulumi.Input['AS2OneWayAgreementArgs']]:
        """
        The AS2 one-way receive agreement.
        """
        return pulumi.get(self, "receive_agreement")

    @receive_agreement.setter
    def receive_agreement(self, value: Optional[pulumi.Input['AS2OneWayAgreementArgs']]):
        pulumi.set(self, "receive_agreement", value)

    @property
    @pulumi.getter(name="sendAgreement")
    def send_agreement(self) -> Optional[pulumi.Input['AS2OneWayAgreementArgs']]:
        """
        The AS2 one-way send agreement.
        """
        return pulumi.get(self, "send_agreement")

    @send_agreement.setter
    def send_agreement(self, value: Optional[pulumi.Input['AS2OneWayAgreementArgs']]):
        pulumi.set(self, "send_agreement", value)


@pulumi.input_type
class AS2EnvelopeSettingsArgs:
    def __init__(__self__, *,
                 autogenerate_file_name: Optional[pulumi.Input[bool]] = None,
                 file_name_template: Optional[pulumi.Input[str]] = None,
                 message_content_type: Optional[pulumi.Input[str]] = None,
                 suspend_message_on_file_name_generation_error: Optional[pulumi.Input[bool]] = None,
                 transmit_file_name_in_mime_header: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] autogenerate_file_name: The value indicating whether to auto generate file name.
        :param pulumi.Input[str] file_name_template: The template for file name.
        :param pulumi.Input[str] message_content_type: The message content type.
        :param pulumi.Input[bool] suspend_message_on_file_name_generation_error: The value indicating whether to suspend message on file name generation error.
        :param pulumi.Input[bool] transmit_file_name_in_mime_header: The value indicating whether to transmit file name in mime header.
        """
        if autogenerate_file_name is not None:
            pulumi.set(__self__, "autogenerate_file_name", autogenerate_file_name)
        if file_name_template is not None:
            pulumi.set(__self__, "file_name_template", file_name_template)
        if message_content_type is not None:
            pulumi.set(__self__, "message_content_type", message_content_type)
        if suspend_message_on_file_name_generation_error is not None:
            pulumi.set(__self__, "suspend_message_on_file_name_generation_error", suspend_message_on_file_name_generation_error)
        if transmit_file_name_in_mime_header is not None:
            pulumi.set(__self__, "transmit_file_name_in_mime_header", transmit_file_name_in_mime_header)

    @property
    @pulumi.getter(name="autogenerateFileName")
    def autogenerate_file_name(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to auto generate file name.
        """
        return pulumi.get(self, "autogenerate_file_name")

    @autogenerate_file_name.setter
    def autogenerate_file_name(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "autogenerate_file_name", value)

    @property
    @pulumi.getter(name="fileNameTemplate")
    def file_name_template(self) -> Optional[pulumi.Input[str]]:
        """
        The template for file name.
        """
        return pulumi.get(self, "file_name_template")

    @file_name_template.setter
    def file_name_template(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "file_name_template", value)

    @property
    @pulumi.getter(name="messageContentType")
    def message_content_type(self) -> Optional[pulumi.Input[str]]:
        """
        The message content type.
        """
        return pulumi.get(self, "message_content_type")

    @message_content_type.setter
    def message_content_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_content_type", value)

    @property
    @pulumi.getter(name="suspendMessageOnFileNameGenerationError")
    def suspend_message_on_file_name_generation_error(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to suspend message on file name generation error.
        """
        return pulumi.get(self, "suspend_message_on_file_name_generation_error")

    @suspend_message_on_file_name_generation_error.setter
    def suspend_message_on_file_name_generation_error(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "suspend_message_on_file_name_generation_error", value)

    @property
    @pulumi.getter(name="transmitFileNameInMimeHeader")
    def transmit_file_name_in_mime_header(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to transmit file name in mime header.
        """
        return pulumi.get(self, "transmit_file_name_in_mime_header")

    @transmit_file_name_in_mime_header.setter
    def transmit_file_name_in_mime_header(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "transmit_file_name_in_mime_header", value)


@pulumi.input_type
class AS2ErrorSettingsArgs:
    def __init__(__self__, *,
                 resend_if_mdn_not_received: Optional[pulumi.Input[bool]] = None,
                 suspend_duplicate_message: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] resend_if_mdn_not_received: The value indicating whether to resend message If MDN is not received.
        :param pulumi.Input[bool] suspend_duplicate_message: The value indicating whether to suspend duplicate message.
        """
        if resend_if_mdn_not_received is not None:
            pulumi.set(__self__, "resend_if_mdn_not_received", resend_if_mdn_not_received)
        if suspend_duplicate_message is not None:
            pulumi.set(__self__, "suspend_duplicate_message", suspend_duplicate_message)

    @property
    @pulumi.getter(name="resendIfMdnNotReceived")
    def resend_if_mdn_not_received(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to resend message If MDN is not received.
        """
        return pulumi.get(self, "resend_if_mdn_not_received")

    @resend_if_mdn_not_received.setter
    def resend_if_mdn_not_received(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "resend_if_mdn_not_received", value)

    @property
    @pulumi.getter(name="suspendDuplicateMessage")
    def suspend_duplicate_message(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to suspend duplicate message.
        """
        return pulumi.get(self, "suspend_duplicate_message")

    @suspend_duplicate_message.setter
    def suspend_duplicate_message(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "suspend_duplicate_message", value)


@pulumi.input_type
class AS2MdnSettingsArgs:
    def __init__(__self__, *,
                 disposition_notification_to: Optional[pulumi.Input[str]] = None,
                 mdn_text: Optional[pulumi.Input[str]] = None,
                 mic_hashing_algorithm: Optional[pulumi.Input['HashingAlgorithm']] = None,
                 need_mdn: Optional[pulumi.Input[bool]] = None,
                 receipt_delivery_url: Optional[pulumi.Input[str]] = None,
                 send_inbound_mdn_to_message_box: Optional[pulumi.Input[bool]] = None,
                 send_mdn_asynchronously: Optional[pulumi.Input[bool]] = None,
                 sign_mdn: Optional[pulumi.Input[bool]] = None,
                 sign_outbound_mdn_if_optional: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] disposition_notification_to: The disposition notification to header value.
        :param pulumi.Input[str] mdn_text: The MDN text.
        :param pulumi.Input['HashingAlgorithm'] mic_hashing_algorithm: The signing or hashing algorithm.
        :param pulumi.Input[bool] need_mdn: The value indicating whether to send or request a MDN.
        :param pulumi.Input[str] receipt_delivery_url: The receipt delivery URL.
        :param pulumi.Input[bool] send_inbound_mdn_to_message_box: The value indicating whether to send inbound MDN to message box.
        :param pulumi.Input[bool] send_mdn_asynchronously: The value indicating whether to send the asynchronous MDN.
        :param pulumi.Input[bool] sign_mdn: The value indicating whether the MDN needs to be signed or not.
        :param pulumi.Input[bool] sign_outbound_mdn_if_optional: The value indicating whether to sign the outbound MDN if optional.
        """
        if disposition_notification_to is not None:
            pulumi.set(__self__, "disposition_notification_to", disposition_notification_to)
        if mdn_text is not None:
            pulumi.set(__self__, "mdn_text", mdn_text)
        if mic_hashing_algorithm is not None:
            pulumi.set(__self__, "mic_hashing_algorithm", mic_hashing_algorithm)
        if need_mdn is not None:
            pulumi.set(__self__, "need_mdn", need_mdn)
        if receipt_delivery_url is not None:
            pulumi.set(__self__, "receipt_delivery_url", receipt_delivery_url)
        if send_inbound_mdn_to_message_box is not None:
            pulumi.set(__self__, "send_inbound_mdn_to_message_box", send_inbound_mdn_to_message_box)
        if send_mdn_asynchronously is not None:
            pulumi.set(__self__, "send_mdn_asynchronously", send_mdn_asynchronously)
        if sign_mdn is not None:
            pulumi.set(__self__, "sign_mdn", sign_mdn)
        if sign_outbound_mdn_if_optional is not None:
            pulumi.set(__self__, "sign_outbound_mdn_if_optional", sign_outbound_mdn_if_optional)

    @property
    @pulumi.getter(name="dispositionNotificationTo")
    def disposition_notification_to(self) -> Optional[pulumi.Input[str]]:
        """
        The disposition notification to header value.
        """
        return pulumi.get(self, "disposition_notification_to")

    @disposition_notification_to.setter
    def disposition_notification_to(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "disposition_notification_to", value)

    @property
    @pulumi.getter(name="mdnText")
    def mdn_text(self) -> Optional[pulumi.Input[str]]:
        """
        The MDN text.
        """
        return pulumi.get(self, "mdn_text")

    @mdn_text.setter
    def mdn_text(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mdn_text", value)

    @property
    @pulumi.getter(name="micHashingAlgorithm")
    def mic_hashing_algorithm(self) -> Optional[pulumi.Input['HashingAlgorithm']]:
        """
        The signing or hashing algorithm.
        """
        return pulumi.get(self, "mic_hashing_algorithm")

    @mic_hashing_algorithm.setter
    def mic_hashing_algorithm(self, value: Optional[pulumi.Input['HashingAlgorithm']]):
        pulumi.set(self, "mic_hashing_algorithm", value)

    @property
    @pulumi.getter(name="needMdn")
    def need_mdn(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to send or request a MDN.
        """
        return pulumi.get(self, "need_mdn")

    @need_mdn.setter
    def need_mdn(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_mdn", value)

    @property
    @pulumi.getter(name="receiptDeliveryUrl")
    def receipt_delivery_url(self) -> Optional[pulumi.Input[str]]:
        """
        The receipt delivery URL.
        """
        return pulumi.get(self, "receipt_delivery_url")

    @receipt_delivery_url.setter
    def receipt_delivery_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receipt_delivery_url", value)

    @property
    @pulumi.getter(name="sendInboundMdnToMessageBox")
    def send_inbound_mdn_to_message_box(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to send inbound MDN to message box.
        """
        return pulumi.get(self, "send_inbound_mdn_to_message_box")

    @send_inbound_mdn_to_message_box.setter
    def send_inbound_mdn_to_message_box(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "send_inbound_mdn_to_message_box", value)

    @property
    @pulumi.getter(name="sendMdnAsynchronously")
    def send_mdn_asynchronously(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to send the asynchronous MDN.
        """
        return pulumi.get(self, "send_mdn_asynchronously")

    @send_mdn_asynchronously.setter
    def send_mdn_asynchronously(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "send_mdn_asynchronously", value)

    @property
    @pulumi.getter(name="signMdn")
    def sign_mdn(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether the MDN needs to be signed or not.
        """
        return pulumi.get(self, "sign_mdn")

    @sign_mdn.setter
    def sign_mdn(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sign_mdn", value)

    @property
    @pulumi.getter(name="signOutboundMdnIfOptional")
    def sign_outbound_mdn_if_optional(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to sign the outbound MDN if optional.
        """
        return pulumi.get(self, "sign_outbound_mdn_if_optional")

    @sign_outbound_mdn_if_optional.setter
    def sign_outbound_mdn_if_optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sign_outbound_mdn_if_optional", value)


@pulumi.input_type
class AS2MessageConnectionSettingsArgs:
    def __init__(__self__, *,
                 ignore_certificate_name_mismatch: Optional[pulumi.Input[bool]] = None,
                 keep_http_connection_alive: Optional[pulumi.Input[bool]] = None,
                 support_http_status_code_continue: Optional[pulumi.Input[bool]] = None,
                 unfold_http_headers: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] ignore_certificate_name_mismatch: The value indicating whether to ignore mismatch in certificate name.
        :param pulumi.Input[bool] keep_http_connection_alive: The value indicating whether to keep the connection alive.
        :param pulumi.Input[bool] support_http_status_code_continue: The value indicating whether to support HTTP status code 'CONTINUE'.
        :param pulumi.Input[bool] unfold_http_headers: The value indicating whether to unfold the HTTP headers.
        """
        if ignore_certificate_name_mismatch is not None:
            pulumi.set(__self__, "ignore_certificate_name_mismatch", ignore_certificate_name_mismatch)
        if keep_http_connection_alive is not None:
            pulumi.set(__self__, "keep_http_connection_alive", keep_http_connection_alive)
        if support_http_status_code_continue is not None:
            pulumi.set(__self__, "support_http_status_code_continue", support_http_status_code_continue)
        if unfold_http_headers is not None:
            pulumi.set(__self__, "unfold_http_headers", unfold_http_headers)

    @property
    @pulumi.getter(name="ignoreCertificateNameMismatch")
    def ignore_certificate_name_mismatch(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to ignore mismatch in certificate name.
        """
        return pulumi.get(self, "ignore_certificate_name_mismatch")

    @ignore_certificate_name_mismatch.setter
    def ignore_certificate_name_mismatch(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ignore_certificate_name_mismatch", value)

    @property
    @pulumi.getter(name="keepHttpConnectionAlive")
    def keep_http_connection_alive(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to keep the connection alive.
        """
        return pulumi.get(self, "keep_http_connection_alive")

    @keep_http_connection_alive.setter
    def keep_http_connection_alive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_http_connection_alive", value)

    @property
    @pulumi.getter(name="supportHttpStatusCodeContinue")
    def support_http_status_code_continue(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to support HTTP status code 'CONTINUE'.
        """
        return pulumi.get(self, "support_http_status_code_continue")

    @support_http_status_code_continue.setter
    def support_http_status_code_continue(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "support_http_status_code_continue", value)

    @property
    @pulumi.getter(name="unfoldHttpHeaders")
    def unfold_http_headers(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to unfold the HTTP headers.
        """
        return pulumi.get(self, "unfold_http_headers")

    @unfold_http_headers.setter
    def unfold_http_headers(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "unfold_http_headers", value)


@pulumi.input_type
class AS2OneWayAgreementArgs:
    def __init__(__self__, *,
                 protocol_settings: Optional[pulumi.Input['AS2ProtocolSettingsArgs']] = None,
                 receiver_business_identity: Optional[pulumi.Input['BusinessIdentityArgs']] = None,
                 sender_business_identity: Optional[pulumi.Input['BusinessIdentityArgs']] = None):
        """
        :param pulumi.Input['AS2ProtocolSettingsArgs'] protocol_settings: The AS2 protocol settings.
        :param pulumi.Input['BusinessIdentityArgs'] receiver_business_identity: The receiver business identity
        :param pulumi.Input['BusinessIdentityArgs'] sender_business_identity: The sender business identity
        """
        if protocol_settings is not None:
            pulumi.set(__self__, "protocol_settings", protocol_settings)
        if receiver_business_identity is not None:
            pulumi.set(__self__, "receiver_business_identity", receiver_business_identity)
        if sender_business_identity is not None:
            pulumi.set(__self__, "sender_business_identity", sender_business_identity)

    @property
    @pulumi.getter(name="protocolSettings")
    def protocol_settings(self) -> Optional[pulumi.Input['AS2ProtocolSettingsArgs']]:
        """
        The AS2 protocol settings.
        """
        return pulumi.get(self, "protocol_settings")

    @protocol_settings.setter
    def protocol_settings(self, value: Optional[pulumi.Input['AS2ProtocolSettingsArgs']]):
        pulumi.set(self, "protocol_settings", value)

    @property
    @pulumi.getter(name="receiverBusinessIdentity")
    def receiver_business_identity(self) -> Optional[pulumi.Input['BusinessIdentityArgs']]:
        """
        The receiver business identity
        """
        return pulumi.get(self, "receiver_business_identity")

    @receiver_business_identity.setter
    def receiver_business_identity(self, value: Optional[pulumi.Input['BusinessIdentityArgs']]):
        pulumi.set(self, "receiver_business_identity", value)

    @property
    @pulumi.getter(name="senderBusinessIdentity")
    def sender_business_identity(self) -> Optional[pulumi.Input['BusinessIdentityArgs']]:
        """
        The sender business identity
        """
        return pulumi.get(self, "sender_business_identity")

    @sender_business_identity.setter
    def sender_business_identity(self, value: Optional[pulumi.Input['BusinessIdentityArgs']]):
        pulumi.set(self, "sender_business_identity", value)


@pulumi.input_type
class AS2ProtocolSettingsArgs:
    def __init__(__self__, *,
                 acknowledgement_connection_settings: Optional[pulumi.Input['AS2AcknowledgementConnectionSettingsArgs']] = None,
                 envelope_settings: Optional[pulumi.Input['AS2EnvelopeSettingsArgs']] = None,
                 error_settings: Optional[pulumi.Input['AS2ErrorSettingsArgs']] = None,
                 mdn_settings: Optional[pulumi.Input['AS2MdnSettingsArgs']] = None,
                 message_connection_settings: Optional[pulumi.Input['AS2MessageConnectionSettingsArgs']] = None,
                 security_settings: Optional[pulumi.Input['AS2SecuritySettingsArgs']] = None,
                 validation_settings: Optional[pulumi.Input['AS2ValidationSettingsArgs']] = None):
        """
        :param pulumi.Input['AS2AcknowledgementConnectionSettingsArgs'] acknowledgement_connection_settings: The acknowledgement connection settings.
        :param pulumi.Input['AS2EnvelopeSettingsArgs'] envelope_settings: The envelope settings.
        :param pulumi.Input['AS2ErrorSettingsArgs'] error_settings: The error settings.
        :param pulumi.Input['AS2MdnSettingsArgs'] mdn_settings: The MDN settings.
        :param pulumi.Input['AS2MessageConnectionSettingsArgs'] message_connection_settings: The message connection settings.
        :param pulumi.Input['AS2SecuritySettingsArgs'] security_settings: The security settings.
        :param pulumi.Input['AS2ValidationSettingsArgs'] validation_settings: The validation settings.
        """
        if acknowledgement_connection_settings is not None:
            pulumi.set(__self__, "acknowledgement_connection_settings", acknowledgement_connection_settings)
        if envelope_settings is not None:
            pulumi.set(__self__, "envelope_settings", envelope_settings)
        if error_settings is not None:
            pulumi.set(__self__, "error_settings", error_settings)
        if mdn_settings is not None:
            pulumi.set(__self__, "mdn_settings", mdn_settings)
        if message_connection_settings is not None:
            pulumi.set(__self__, "message_connection_settings", message_connection_settings)
        if security_settings is not None:
            pulumi.set(__self__, "security_settings", security_settings)
        if validation_settings is not None:
            pulumi.set(__self__, "validation_settings", validation_settings)

    @property
    @pulumi.getter(name="acknowledgementConnectionSettings")
    def acknowledgement_connection_settings(self) -> Optional[pulumi.Input['AS2AcknowledgementConnectionSettingsArgs']]:
        """
        The acknowledgement connection settings.
        """
        return pulumi.get(self, "acknowledgement_connection_settings")

    @acknowledgement_connection_settings.setter
    def acknowledgement_connection_settings(self, value: Optional[pulumi.Input['AS2AcknowledgementConnectionSettingsArgs']]):
        pulumi.set(self, "acknowledgement_connection_settings", value)

    @property
    @pulumi.getter(name="envelopeSettings")
    def envelope_settings(self) -> Optional[pulumi.Input['AS2EnvelopeSettingsArgs']]:
        """
        The envelope settings.
        """
        return pulumi.get(self, "envelope_settings")

    @envelope_settings.setter
    def envelope_settings(self, value: Optional[pulumi.Input['AS2EnvelopeSettingsArgs']]):
        pulumi.set(self, "envelope_settings", value)

    @property
    @pulumi.getter(name="errorSettings")
    def error_settings(self) -> Optional[pulumi.Input['AS2ErrorSettingsArgs']]:
        """
        The error settings.
        """
        return pulumi.get(self, "error_settings")

    @error_settings.setter
    def error_settings(self, value: Optional[pulumi.Input['AS2ErrorSettingsArgs']]):
        pulumi.set(self, "error_settings", value)

    @property
    @pulumi.getter(name="mdnSettings")
    def mdn_settings(self) -> Optional[pulumi.Input['AS2MdnSettingsArgs']]:
        """
        The MDN settings.
        """
        return pulumi.get(self, "mdn_settings")

    @mdn_settings.setter
    def mdn_settings(self, value: Optional[pulumi.Input['AS2MdnSettingsArgs']]):
        pulumi.set(self, "mdn_settings", value)

    @property
    @pulumi.getter(name="messageConnectionSettings")
    def message_connection_settings(self) -> Optional[pulumi.Input['AS2MessageConnectionSettingsArgs']]:
        """
        The message connection settings.
        """
        return pulumi.get(self, "message_connection_settings")

    @message_connection_settings.setter
    def message_connection_settings(self, value: Optional[pulumi.Input['AS2MessageConnectionSettingsArgs']]):
        pulumi.set(self, "message_connection_settings", value)

    @property
    @pulumi.getter(name="securitySettings")
    def security_settings(self) -> Optional[pulumi.Input['AS2SecuritySettingsArgs']]:
        """
        The security settings.
        """
        return pulumi.get(self, "security_settings")

    @security_settings.setter
    def security_settings(self, value: Optional[pulumi.Input['AS2SecuritySettingsArgs']]):
        pulumi.set(self, "security_settings", value)

    @property
    @pulumi.getter(name="validationSettings")
    def validation_settings(self) -> Optional[pulumi.Input['AS2ValidationSettingsArgs']]:
        """
        The validation settings.
        """
        return pulumi.get(self, "validation_settings")

    @validation_settings.setter
    def validation_settings(self, value: Optional[pulumi.Input['AS2ValidationSettingsArgs']]):
        pulumi.set(self, "validation_settings", value)


@pulumi.input_type
class AS2SecuritySettingsArgs:
    def __init__(__self__, *,
                 enable_nrr_for_inbound_decoded_messages: Optional[pulumi.Input[bool]] = None,
                 enable_nrr_for_inbound_encoded_messages: Optional[pulumi.Input[bool]] = None,
                 enable_nrr_for_inbound_mdn: Optional[pulumi.Input[bool]] = None,
                 enable_nrr_for_outbound_decoded_messages: Optional[pulumi.Input[bool]] = None,
                 enable_nrr_for_outbound_encoded_messages: Optional[pulumi.Input[bool]] = None,
                 enable_nrr_for_outbound_mdn: Optional[pulumi.Input[bool]] = None,
                 encryption_certificate_name: Optional[pulumi.Input[str]] = None,
                 override_group_signing_certificate: Optional[pulumi.Input[bool]] = None,
                 signing_certificate_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enable_nrr_for_inbound_decoded_messages: The value indicating whether to enable NRR for inbound decoded messages.
        :param pulumi.Input[bool] enable_nrr_for_inbound_encoded_messages: The value indicating whether to enable NRR for inbound encoded messages.
        :param pulumi.Input[bool] enable_nrr_for_inbound_mdn: The value indicating whether to enable NRR for inbound MDN.
        :param pulumi.Input[bool] enable_nrr_for_outbound_decoded_messages: The value indicating whether to enable NRR for outbound decoded messages.
        :param pulumi.Input[bool] enable_nrr_for_outbound_encoded_messages: The value indicating whether to enable NRR for outbound encoded messages.
        :param pulumi.Input[bool] enable_nrr_for_outbound_mdn: The value indicating whether to enable NRR for outbound MDN.
        :param pulumi.Input[str] encryption_certificate_name: The name of the encryption certificate.
        :param pulumi.Input[bool] override_group_signing_certificate: The value indicating whether to send or request a MDN.
        :param pulumi.Input[str] signing_certificate_name: The name of the signing certificate.
        """
        if enable_nrr_for_inbound_decoded_messages is not None:
            pulumi.set(__self__, "enable_nrr_for_inbound_decoded_messages", enable_nrr_for_inbound_decoded_messages)
        if enable_nrr_for_inbound_encoded_messages is not None:
            pulumi.set(__self__, "enable_nrr_for_inbound_encoded_messages", enable_nrr_for_inbound_encoded_messages)
        if enable_nrr_for_inbound_mdn is not None:
            pulumi.set(__self__, "enable_nrr_for_inbound_mdn", enable_nrr_for_inbound_mdn)
        if enable_nrr_for_outbound_decoded_messages is not None:
            pulumi.set(__self__, "enable_nrr_for_outbound_decoded_messages", enable_nrr_for_outbound_decoded_messages)
        if enable_nrr_for_outbound_encoded_messages is not None:
            pulumi.set(__self__, "enable_nrr_for_outbound_encoded_messages", enable_nrr_for_outbound_encoded_messages)
        if enable_nrr_for_outbound_mdn is not None:
            pulumi.set(__self__, "enable_nrr_for_outbound_mdn", enable_nrr_for_outbound_mdn)
        if encryption_certificate_name is not None:
            pulumi.set(__self__, "encryption_certificate_name", encryption_certificate_name)
        if override_group_signing_certificate is not None:
            pulumi.set(__self__, "override_group_signing_certificate", override_group_signing_certificate)
        if signing_certificate_name is not None:
            pulumi.set(__self__, "signing_certificate_name", signing_certificate_name)

    @property
    @pulumi.getter(name="enableNrrForInboundDecodedMessages")
    def enable_nrr_for_inbound_decoded_messages(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable NRR for inbound decoded messages.
        """
        return pulumi.get(self, "enable_nrr_for_inbound_decoded_messages")

    @enable_nrr_for_inbound_decoded_messages.setter
    def enable_nrr_for_inbound_decoded_messages(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nrr_for_inbound_decoded_messages", value)

    @property
    @pulumi.getter(name="enableNrrForInboundEncodedMessages")
    def enable_nrr_for_inbound_encoded_messages(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable NRR for inbound encoded messages.
        """
        return pulumi.get(self, "enable_nrr_for_inbound_encoded_messages")

    @enable_nrr_for_inbound_encoded_messages.setter
    def enable_nrr_for_inbound_encoded_messages(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nrr_for_inbound_encoded_messages", value)

    @property
    @pulumi.getter(name="enableNrrForInboundMdn")
    def enable_nrr_for_inbound_mdn(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable NRR for inbound MDN.
        """
        return pulumi.get(self, "enable_nrr_for_inbound_mdn")

    @enable_nrr_for_inbound_mdn.setter
    def enable_nrr_for_inbound_mdn(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nrr_for_inbound_mdn", value)

    @property
    @pulumi.getter(name="enableNrrForOutboundDecodedMessages")
    def enable_nrr_for_outbound_decoded_messages(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable NRR for outbound decoded messages.
        """
        return pulumi.get(self, "enable_nrr_for_outbound_decoded_messages")

    @enable_nrr_for_outbound_decoded_messages.setter
    def enable_nrr_for_outbound_decoded_messages(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nrr_for_outbound_decoded_messages", value)

    @property
    @pulumi.getter(name="enableNrrForOutboundEncodedMessages")
    def enable_nrr_for_outbound_encoded_messages(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable NRR for outbound encoded messages.
        """
        return pulumi.get(self, "enable_nrr_for_outbound_encoded_messages")

    @enable_nrr_for_outbound_encoded_messages.setter
    def enable_nrr_for_outbound_encoded_messages(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nrr_for_outbound_encoded_messages", value)

    @property
    @pulumi.getter(name="enableNrrForOutboundMdn")
    def enable_nrr_for_outbound_mdn(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable NRR for outbound MDN.
        """
        return pulumi.get(self, "enable_nrr_for_outbound_mdn")

    @enable_nrr_for_outbound_mdn.setter
    def enable_nrr_for_outbound_mdn(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_nrr_for_outbound_mdn", value)

    @property
    @pulumi.getter(name="encryptionCertificateName")
    def encryption_certificate_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the encryption certificate.
        """
        return pulumi.get(self, "encryption_certificate_name")

    @encryption_certificate_name.setter
    def encryption_certificate_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "encryption_certificate_name", value)

    @property
    @pulumi.getter(name="overrideGroupSigningCertificate")
    def override_group_signing_certificate(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to send or request a MDN.
        """
        return pulumi.get(self, "override_group_signing_certificate")

    @override_group_signing_certificate.setter
    def override_group_signing_certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "override_group_signing_certificate", value)

    @property
    @pulumi.getter(name="signingCertificateName")
    def signing_certificate_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the signing certificate.
        """
        return pulumi.get(self, "signing_certificate_name")

    @signing_certificate_name.setter
    def signing_certificate_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "signing_certificate_name", value)


@pulumi.input_type
class AS2ValidationSettingsArgs:
    def __init__(__self__, *,
                 check_certificate_revocation_list_on_receive: Optional[pulumi.Input[bool]] = None,
                 check_certificate_revocation_list_on_send: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_message: Optional[pulumi.Input[bool]] = None,
                 compress_message: Optional[pulumi.Input[bool]] = None,
                 encrypt_message: Optional[pulumi.Input[bool]] = None,
                 encryption_algorithm: Optional[pulumi.Input['EncryptionAlgorithm']] = None,
                 interchange_duplicates_validity_days: Optional[pulumi.Input[int]] = None,
                 override_message_properties: Optional[pulumi.Input[bool]] = None,
                 sign_message: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] check_certificate_revocation_list_on_receive: The value indicating whether to check for certificate revocation list on receive.
        :param pulumi.Input[bool] check_certificate_revocation_list_on_send: The value indicating whether to check for certificate revocation list on send.
        :param pulumi.Input[bool] check_duplicate_message: The value indicating whether to check for duplicate message.
        :param pulumi.Input[bool] compress_message: The value indicating whether the message has to be compressed.
        :param pulumi.Input[bool] encrypt_message: The value indicating whether the message has to be encrypted.
        :param pulumi.Input['EncryptionAlgorithm'] encryption_algorithm: The encryption algorithm.
        :param pulumi.Input[int] interchange_duplicates_validity_days: The number of days to look back for duplicate interchange.
        :param pulumi.Input[bool] override_message_properties: The value indicating whether to override incoming message properties with those in agreement.
        :param pulumi.Input[bool] sign_message: The value indicating whether the message has to be signed.
        """
        if check_certificate_revocation_list_on_receive is not None:
            pulumi.set(__self__, "check_certificate_revocation_list_on_receive", check_certificate_revocation_list_on_receive)
        if check_certificate_revocation_list_on_send is not None:
            pulumi.set(__self__, "check_certificate_revocation_list_on_send", check_certificate_revocation_list_on_send)
        if check_duplicate_message is not None:
            pulumi.set(__self__, "check_duplicate_message", check_duplicate_message)
        if compress_message is not None:
            pulumi.set(__self__, "compress_message", compress_message)
        if encrypt_message is not None:
            pulumi.set(__self__, "encrypt_message", encrypt_message)
        if encryption_algorithm is not None:
            pulumi.set(__self__, "encryption_algorithm", encryption_algorithm)
        if interchange_duplicates_validity_days is not None:
            pulumi.set(__self__, "interchange_duplicates_validity_days", interchange_duplicates_validity_days)
        if override_message_properties is not None:
            pulumi.set(__self__, "override_message_properties", override_message_properties)
        if sign_message is not None:
            pulumi.set(__self__, "sign_message", sign_message)

    @property
    @pulumi.getter(name="checkCertificateRevocationListOnReceive")
    def check_certificate_revocation_list_on_receive(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for certificate revocation list on receive.
        """
        return pulumi.get(self, "check_certificate_revocation_list_on_receive")

    @check_certificate_revocation_list_on_receive.setter
    def check_certificate_revocation_list_on_receive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_certificate_revocation_list_on_receive", value)

    @property
    @pulumi.getter(name="checkCertificateRevocationListOnSend")
    def check_certificate_revocation_list_on_send(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for certificate revocation list on send.
        """
        return pulumi.get(self, "check_certificate_revocation_list_on_send")

    @check_certificate_revocation_list_on_send.setter
    def check_certificate_revocation_list_on_send(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_certificate_revocation_list_on_send", value)

    @property
    @pulumi.getter(name="checkDuplicateMessage")
    def check_duplicate_message(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate message.
        """
        return pulumi.get(self, "check_duplicate_message")

    @check_duplicate_message.setter
    def check_duplicate_message(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_message", value)

    @property
    @pulumi.getter(name="compressMessage")
    def compress_message(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether the message has to be compressed.
        """
        return pulumi.get(self, "compress_message")

    @compress_message.setter
    def compress_message(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "compress_message", value)

    @property
    @pulumi.getter(name="encryptMessage")
    def encrypt_message(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether the message has to be encrypted.
        """
        return pulumi.get(self, "encrypt_message")

    @encrypt_message.setter
    def encrypt_message(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "encrypt_message", value)

    @property
    @pulumi.getter(name="encryptionAlgorithm")
    def encryption_algorithm(self) -> Optional[pulumi.Input['EncryptionAlgorithm']]:
        """
        The encryption algorithm.
        """
        return pulumi.get(self, "encryption_algorithm")

    @encryption_algorithm.setter
    def encryption_algorithm(self, value: Optional[pulumi.Input['EncryptionAlgorithm']]):
        pulumi.set(self, "encryption_algorithm", value)

    @property
    @pulumi.getter(name="interchangeDuplicatesValidityDays")
    def interchange_duplicates_validity_days(self) -> Optional[pulumi.Input[int]]:
        """
        The number of days to look back for duplicate interchange.
        """
        return pulumi.get(self, "interchange_duplicates_validity_days")

    @interchange_duplicates_validity_days.setter
    def interchange_duplicates_validity_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interchange_duplicates_validity_days", value)

    @property
    @pulumi.getter(name="overrideMessageProperties")
    def override_message_properties(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to override incoming message properties with those in agreement.
        """
        return pulumi.get(self, "override_message_properties")

    @override_message_properties.setter
    def override_message_properties(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "override_message_properties", value)

    @property
    @pulumi.getter(name="signMessage")
    def sign_message(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether the message has to be signed.
        """
        return pulumi.get(self, "sign_message")

    @sign_message.setter
    def sign_message(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sign_message", value)


@pulumi.input_type
class AgreementContentArgs:
    def __init__(__self__, *,
                 a_s2: Optional[pulumi.Input['AS2AgreementContentArgs']] = None,
                 edifact: Optional[pulumi.Input['EdifactAgreementContentArgs']] = None,
                 x12: Optional[pulumi.Input['X12AgreementContentArgs']] = None):
        """
        :param pulumi.Input['AS2AgreementContentArgs'] a_s2: The AS2 agreement content.
        :param pulumi.Input['EdifactAgreementContentArgs'] edifact: The EDIFACT agreement content.
        :param pulumi.Input['X12AgreementContentArgs'] x12: The X12 agreement content.
        """
        if a_s2 is not None:
            pulumi.set(__self__, "a_s2", a_s2)
        if edifact is not None:
            pulumi.set(__self__, "edifact", edifact)
        if x12 is not None:
            pulumi.set(__self__, "x12", x12)

    @property
    @pulumi.getter(name="aS2")
    def a_s2(self) -> Optional[pulumi.Input['AS2AgreementContentArgs']]:
        """
        The AS2 agreement content.
        """
        return pulumi.get(self, "a_s2")

    @a_s2.setter
    def a_s2(self, value: Optional[pulumi.Input['AS2AgreementContentArgs']]):
        pulumi.set(self, "a_s2", value)

    @property
    @pulumi.getter
    def edifact(self) -> Optional[pulumi.Input['EdifactAgreementContentArgs']]:
        """
        The EDIFACT agreement content.
        """
        return pulumi.get(self, "edifact")

    @edifact.setter
    def edifact(self, value: Optional[pulumi.Input['EdifactAgreementContentArgs']]):
        pulumi.set(self, "edifact", value)

    @property
    @pulumi.getter
    def x12(self) -> Optional[pulumi.Input['X12AgreementContentArgs']]:
        """
        The X12 agreement content.
        """
        return pulumi.get(self, "x12")

    @x12.setter
    def x12(self, value: Optional[pulumi.Input['X12AgreementContentArgs']]):
        pulumi.set(self, "x12", value)


@pulumi.input_type
class B2BPartnerContentArgs:
    def __init__(__self__, *,
                 business_identities: Optional[pulumi.Input[Sequence[pulumi.Input['BusinessIdentityArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['BusinessIdentityArgs']]] business_identities: The list of partner business identities.
        """
        if business_identities is not None:
            pulumi.set(__self__, "business_identities", business_identities)

    @property
    @pulumi.getter(name="businessIdentities")
    def business_identities(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BusinessIdentityArgs']]]]:
        """
        The list of partner business identities.
        """
        return pulumi.get(self, "business_identities")

    @business_identities.setter
    def business_identities(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BusinessIdentityArgs']]]]):
        pulumi.set(self, "business_identities", value)


@pulumi.input_type
class BusinessIdentityArgs:
    def __init__(__self__, *,
                 qualifier: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] qualifier: The business identity qualifier.
        :param pulumi.Input[str] value: The business identity value.
        """
        if qualifier is not None:
            pulumi.set(__self__, "qualifier", qualifier)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The business identity qualifier.
        """
        return pulumi.get(self, "qualifier")

    @qualifier.setter
    def qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "qualifier", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        The business identity value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class EdifactAcknowledgementSettingsArgs:
    def __init__(__self__, *,
                 acknowledgement_control_number_lower_bound: Optional[pulumi.Input[int]] = None,
                 acknowledgement_control_number_prefix: Optional[pulumi.Input[str]] = None,
                 acknowledgement_control_number_suffix: Optional[pulumi.Input[str]] = None,
                 acknowledgement_control_number_upper_bound: Optional[pulumi.Input[int]] = None,
                 batch_functional_acknowledgements: Optional[pulumi.Input[bool]] = None,
                 batch_technical_acknowledgements: Optional[pulumi.Input[bool]] = None,
                 need_functional_acknowledgement: Optional[pulumi.Input[bool]] = None,
                 need_loop_for_valid_messages: Optional[pulumi.Input[bool]] = None,
                 need_technical_acknowledgement: Optional[pulumi.Input[bool]] = None,
                 rollover_acknowledgement_control_number: Optional[pulumi.Input[bool]] = None,
                 send_synchronous_acknowledgement: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[int] acknowledgement_control_number_lower_bound: The acknowledgement control number lower bound.
        :param pulumi.Input[str] acknowledgement_control_number_prefix: The acknowledgement control number prefix.
        :param pulumi.Input[str] acknowledgement_control_number_suffix: The acknowledgement control number suffix.
        :param pulumi.Input[int] acknowledgement_control_number_upper_bound: The acknowledgement control number upper bound.
        :param pulumi.Input[bool] batch_functional_acknowledgements: The value indicating whether to batch functional acknowledgements.
        :param pulumi.Input[bool] batch_technical_acknowledgements: The value indicating whether to batch the technical acknowledgements.
        :param pulumi.Input[bool] need_functional_acknowledgement: The value indicating whether functional acknowledgement is needed.
        :param pulumi.Input[bool] need_loop_for_valid_messages: The value indicating whether a loop is needed for valid messages.
        :param pulumi.Input[bool] need_technical_acknowledgement: The value indicating whether technical acknowledgement is needed.
        :param pulumi.Input[bool] rollover_acknowledgement_control_number: The value indicating whether to rollover acknowledgement control number.
        :param pulumi.Input[bool] send_synchronous_acknowledgement: The value indicating whether to send synchronous acknowledgement.
        """
        if acknowledgement_control_number_lower_bound is not None:
            pulumi.set(__self__, "acknowledgement_control_number_lower_bound", acknowledgement_control_number_lower_bound)
        if acknowledgement_control_number_prefix is not None:
            pulumi.set(__self__, "acknowledgement_control_number_prefix", acknowledgement_control_number_prefix)
        if acknowledgement_control_number_suffix is not None:
            pulumi.set(__self__, "acknowledgement_control_number_suffix", acknowledgement_control_number_suffix)
        if acknowledgement_control_number_upper_bound is not None:
            pulumi.set(__self__, "acknowledgement_control_number_upper_bound", acknowledgement_control_number_upper_bound)
        if batch_functional_acknowledgements is not None:
            pulumi.set(__self__, "batch_functional_acknowledgements", batch_functional_acknowledgements)
        if batch_technical_acknowledgements is not None:
            pulumi.set(__self__, "batch_technical_acknowledgements", batch_technical_acknowledgements)
        if need_functional_acknowledgement is not None:
            pulumi.set(__self__, "need_functional_acknowledgement", need_functional_acknowledgement)
        if need_loop_for_valid_messages is not None:
            pulumi.set(__self__, "need_loop_for_valid_messages", need_loop_for_valid_messages)
        if need_technical_acknowledgement is not None:
            pulumi.set(__self__, "need_technical_acknowledgement", need_technical_acknowledgement)
        if rollover_acknowledgement_control_number is not None:
            pulumi.set(__self__, "rollover_acknowledgement_control_number", rollover_acknowledgement_control_number)
        if send_synchronous_acknowledgement is not None:
            pulumi.set(__self__, "send_synchronous_acknowledgement", send_synchronous_acknowledgement)

    @property
    @pulumi.getter(name="acknowledgementControlNumberLowerBound")
    def acknowledgement_control_number_lower_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The acknowledgement control number lower bound.
        """
        return pulumi.get(self, "acknowledgement_control_number_lower_bound")

    @acknowledgement_control_number_lower_bound.setter
    def acknowledgement_control_number_lower_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "acknowledgement_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="acknowledgementControlNumberPrefix")
    def acknowledgement_control_number_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The acknowledgement control number prefix.
        """
        return pulumi.get(self, "acknowledgement_control_number_prefix")

    @acknowledgement_control_number_prefix.setter
    def acknowledgement_control_number_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "acknowledgement_control_number_prefix", value)

    @property
    @pulumi.getter(name="acknowledgementControlNumberSuffix")
    def acknowledgement_control_number_suffix(self) -> Optional[pulumi.Input[str]]:
        """
        The acknowledgement control number suffix.
        """
        return pulumi.get(self, "acknowledgement_control_number_suffix")

    @acknowledgement_control_number_suffix.setter
    def acknowledgement_control_number_suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "acknowledgement_control_number_suffix", value)

    @property
    @pulumi.getter(name="acknowledgementControlNumberUpperBound")
    def acknowledgement_control_number_upper_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The acknowledgement control number upper bound.
        """
        return pulumi.get(self, "acknowledgement_control_number_upper_bound")

    @acknowledgement_control_number_upper_bound.setter
    def acknowledgement_control_number_upper_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "acknowledgement_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="batchFunctionalAcknowledgements")
    def batch_functional_acknowledgements(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to batch functional acknowledgements.
        """
        return pulumi.get(self, "batch_functional_acknowledgements")

    @batch_functional_acknowledgements.setter
    def batch_functional_acknowledgements(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_functional_acknowledgements", value)

    @property
    @pulumi.getter(name="batchTechnicalAcknowledgements")
    def batch_technical_acknowledgements(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to batch the technical acknowledgements.
        """
        return pulumi.get(self, "batch_technical_acknowledgements")

    @batch_technical_acknowledgements.setter
    def batch_technical_acknowledgements(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_technical_acknowledgements", value)

    @property
    @pulumi.getter(name="needFunctionalAcknowledgement")
    def need_functional_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether functional acknowledgement is needed.
        """
        return pulumi.get(self, "need_functional_acknowledgement")

    @need_functional_acknowledgement.setter
    def need_functional_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_functional_acknowledgement", value)

    @property
    @pulumi.getter(name="needLoopForValidMessages")
    def need_loop_for_valid_messages(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether a loop is needed for valid messages.
        """
        return pulumi.get(self, "need_loop_for_valid_messages")

    @need_loop_for_valid_messages.setter
    def need_loop_for_valid_messages(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_loop_for_valid_messages", value)

    @property
    @pulumi.getter(name="needTechnicalAcknowledgement")
    def need_technical_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether technical acknowledgement is needed.
        """
        return pulumi.get(self, "need_technical_acknowledgement")

    @need_technical_acknowledgement.setter
    def need_technical_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_technical_acknowledgement", value)

    @property
    @pulumi.getter(name="rolloverAcknowledgementControlNumber")
    def rollover_acknowledgement_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover acknowledgement control number.
        """
        return pulumi.get(self, "rollover_acknowledgement_control_number")

    @rollover_acknowledgement_control_number.setter
    def rollover_acknowledgement_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_acknowledgement_control_number", value)

    @property
    @pulumi.getter(name="sendSynchronousAcknowledgement")
    def send_synchronous_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to send synchronous acknowledgement.
        """
        return pulumi.get(self, "send_synchronous_acknowledgement")

    @send_synchronous_acknowledgement.setter
    def send_synchronous_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "send_synchronous_acknowledgement", value)


@pulumi.input_type
class EdifactAgreementContentArgs:
    def __init__(__self__, *,
                 receive_agreement: Optional[pulumi.Input['EdifactOneWayAgreementArgs']] = None,
                 send_agreement: Optional[pulumi.Input['EdifactOneWayAgreementArgs']] = None):
        """
        :param pulumi.Input['EdifactOneWayAgreementArgs'] receive_agreement: The EDIFACT one-way receive agreement.
        :param pulumi.Input['EdifactOneWayAgreementArgs'] send_agreement: The EDIFACT one-way send agreement.
        """
        if receive_agreement is not None:
            pulumi.set(__self__, "receive_agreement", receive_agreement)
        if send_agreement is not None:
            pulumi.set(__self__, "send_agreement", send_agreement)

    @property
    @pulumi.getter(name="receiveAgreement")
    def receive_agreement(self) -> Optional[pulumi.Input['EdifactOneWayAgreementArgs']]:
        """
        The EDIFACT one-way receive agreement.
        """
        return pulumi.get(self, "receive_agreement")

    @receive_agreement.setter
    def receive_agreement(self, value: Optional[pulumi.Input['EdifactOneWayAgreementArgs']]):
        pulumi.set(self, "receive_agreement", value)

    @property
    @pulumi.getter(name="sendAgreement")
    def send_agreement(self) -> Optional[pulumi.Input['EdifactOneWayAgreementArgs']]:
        """
        The EDIFACT one-way send agreement.
        """
        return pulumi.get(self, "send_agreement")

    @send_agreement.setter
    def send_agreement(self, value: Optional[pulumi.Input['EdifactOneWayAgreementArgs']]):
        pulumi.set(self, "send_agreement", value)


@pulumi.input_type
class EdifactDelimiterOverrideArgs:
    def __init__(__self__, *,
                 component_separator: Optional[pulumi.Input[int]] = None,
                 data_element_separator: Optional[pulumi.Input[int]] = None,
                 decimal_point_indicator: Optional[pulumi.Input['EdifactDecimalIndicator']] = None,
                 message_association_assigned_code: Optional[pulumi.Input[str]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 message_release: Optional[pulumi.Input[str]] = None,
                 message_version: Optional[pulumi.Input[str]] = None,
                 release_indicator: Optional[pulumi.Input[int]] = None,
                 repetition_separator: Optional[pulumi.Input[int]] = None,
                 segment_terminator: Optional[pulumi.Input[int]] = None,
                 segment_terminator_suffix: Optional[pulumi.Input['SegmentTerminatorSuffix']] = None,
                 target_namespace: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] component_separator: The component separator.
        :param pulumi.Input[int] data_element_separator: The data element separator.
        :param pulumi.Input['EdifactDecimalIndicator'] decimal_point_indicator: The decimal point indicator.
        :param pulumi.Input[str] message_association_assigned_code: The message association assigned code.
        :param pulumi.Input[str] message_id: The message id.
        :param pulumi.Input[str] message_release: The message release version.
        :param pulumi.Input[str] message_version: The message version.
        :param pulumi.Input[int] release_indicator: The release indicator.
        :param pulumi.Input[int] repetition_separator: The repetition separator.
        :param pulumi.Input[int] segment_terminator: The segment terminator.
        :param pulumi.Input['SegmentTerminatorSuffix'] segment_terminator_suffix: The segment terminator suffix.
        :param pulumi.Input[str] target_namespace: The target namespace on which this delimiter settings has to be applied.
        """
        if component_separator is not None:
            pulumi.set(__self__, "component_separator", component_separator)
        if data_element_separator is not None:
            pulumi.set(__self__, "data_element_separator", data_element_separator)
        if decimal_point_indicator is not None:
            pulumi.set(__self__, "decimal_point_indicator", decimal_point_indicator)
        if message_association_assigned_code is not None:
            pulumi.set(__self__, "message_association_assigned_code", message_association_assigned_code)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if message_release is not None:
            pulumi.set(__self__, "message_release", message_release)
        if message_version is not None:
            pulumi.set(__self__, "message_version", message_version)
        if release_indicator is not None:
            pulumi.set(__self__, "release_indicator", release_indicator)
        if repetition_separator is not None:
            pulumi.set(__self__, "repetition_separator", repetition_separator)
        if segment_terminator is not None:
            pulumi.set(__self__, "segment_terminator", segment_terminator)
        if segment_terminator_suffix is not None:
            pulumi.set(__self__, "segment_terminator_suffix", segment_terminator_suffix)
        if target_namespace is not None:
            pulumi.set(__self__, "target_namespace", target_namespace)

    @property
    @pulumi.getter(name="componentSeparator")
    def component_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The component separator.
        """
        return pulumi.get(self, "component_separator")

    @component_separator.setter
    def component_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "component_separator", value)

    @property
    @pulumi.getter(name="dataElementSeparator")
    def data_element_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The data element separator.
        """
        return pulumi.get(self, "data_element_separator")

    @data_element_separator.setter
    def data_element_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "data_element_separator", value)

    @property
    @pulumi.getter(name="decimalPointIndicator")
    def decimal_point_indicator(self) -> Optional[pulumi.Input['EdifactDecimalIndicator']]:
        """
        The decimal point indicator.
        """
        return pulumi.get(self, "decimal_point_indicator")

    @decimal_point_indicator.setter
    def decimal_point_indicator(self, value: Optional[pulumi.Input['EdifactDecimalIndicator']]):
        pulumi.set(self, "decimal_point_indicator", value)

    @property
    @pulumi.getter(name="messageAssociationAssignedCode")
    def message_association_assigned_code(self) -> Optional[pulumi.Input[str]]:
        """
        The message association assigned code.
        """
        return pulumi.get(self, "message_association_assigned_code")

    @message_association_assigned_code.setter
    def message_association_assigned_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_association_assigned_code", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="messageRelease")
    def message_release(self) -> Optional[pulumi.Input[str]]:
        """
        The message release version.
        """
        return pulumi.get(self, "message_release")

    @message_release.setter
    def message_release(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_release", value)

    @property
    @pulumi.getter(name="messageVersion")
    def message_version(self) -> Optional[pulumi.Input[str]]:
        """
        The message version.
        """
        return pulumi.get(self, "message_version")

    @message_version.setter
    def message_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_version", value)

    @property
    @pulumi.getter(name="releaseIndicator")
    def release_indicator(self) -> Optional[pulumi.Input[int]]:
        """
        The release indicator.
        """
        return pulumi.get(self, "release_indicator")

    @release_indicator.setter
    def release_indicator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "release_indicator", value)

    @property
    @pulumi.getter(name="repetitionSeparator")
    def repetition_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The repetition separator.
        """
        return pulumi.get(self, "repetition_separator")

    @repetition_separator.setter
    def repetition_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "repetition_separator", value)

    @property
    @pulumi.getter(name="segmentTerminator")
    def segment_terminator(self) -> Optional[pulumi.Input[int]]:
        """
        The segment terminator.
        """
        return pulumi.get(self, "segment_terminator")

    @segment_terminator.setter
    def segment_terminator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "segment_terminator", value)

    @property
    @pulumi.getter(name="segmentTerminatorSuffix")
    def segment_terminator_suffix(self) -> Optional[pulumi.Input['SegmentTerminatorSuffix']]:
        """
        The segment terminator suffix.
        """
        return pulumi.get(self, "segment_terminator_suffix")

    @segment_terminator_suffix.setter
    def segment_terminator_suffix(self, value: Optional[pulumi.Input['SegmentTerminatorSuffix']]):
        pulumi.set(self, "segment_terminator_suffix", value)

    @property
    @pulumi.getter(name="targetNamespace")
    def target_namespace(self) -> Optional[pulumi.Input[str]]:
        """
        The target namespace on which this delimiter settings has to be applied.
        """
        return pulumi.get(self, "target_namespace")

    @target_namespace.setter
    def target_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_namespace", value)


@pulumi.input_type
class EdifactEnvelopeOverrideArgs:
    def __init__(__self__, *,
                 application_password: Optional[pulumi.Input[str]] = None,
                 association_assigned_code: Optional[pulumi.Input[str]] = None,
                 controlling_agency_code: Optional[pulumi.Input[str]] = None,
                 functional_group_id: Optional[pulumi.Input[str]] = None,
                 group_header_message_release: Optional[pulumi.Input[str]] = None,
                 group_header_message_version: Optional[pulumi.Input[str]] = None,
                 message_association_assigned_code: Optional[pulumi.Input[str]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 message_release: Optional[pulumi.Input[str]] = None,
                 message_version: Optional[pulumi.Input[str]] = None,
                 receiver_application_id: Optional[pulumi.Input[str]] = None,
                 receiver_application_qualifier: Optional[pulumi.Input[str]] = None,
                 sender_application_id: Optional[pulumi.Input[str]] = None,
                 sender_application_qualifier: Optional[pulumi.Input[str]] = None,
                 target_namespace: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] application_password: The application password.
        :param pulumi.Input[str] association_assigned_code: The association assigned code.
        :param pulumi.Input[str] controlling_agency_code: The controlling agency code.
        :param pulumi.Input[str] functional_group_id: The functional group id.
        :param pulumi.Input[str] group_header_message_release: The group header message release.
        :param pulumi.Input[str] group_header_message_version: The group header message version.
        :param pulumi.Input[str] message_association_assigned_code: The message association assigned code.
        :param pulumi.Input[str] message_id: The message id on which this envelope settings has to be applied.
        :param pulumi.Input[str] message_release: The message release version on which this envelope settings has to be applied.
        :param pulumi.Input[str] message_version: The message version on which this envelope settings has to be applied.
        :param pulumi.Input[str] receiver_application_id: The receiver application id.
        :param pulumi.Input[str] receiver_application_qualifier: The receiver application qualifier.
        :param pulumi.Input[str] sender_application_id: The sender application id.
        :param pulumi.Input[str] sender_application_qualifier: The sender application qualifier.
        :param pulumi.Input[str] target_namespace: The target namespace on which this envelope settings has to be applied.
        """
        if application_password is not None:
            pulumi.set(__self__, "application_password", application_password)
        if association_assigned_code is not None:
            pulumi.set(__self__, "association_assigned_code", association_assigned_code)
        if controlling_agency_code is not None:
            pulumi.set(__self__, "controlling_agency_code", controlling_agency_code)
        if functional_group_id is not None:
            pulumi.set(__self__, "functional_group_id", functional_group_id)
        if group_header_message_release is not None:
            pulumi.set(__self__, "group_header_message_release", group_header_message_release)
        if group_header_message_version is not None:
            pulumi.set(__self__, "group_header_message_version", group_header_message_version)
        if message_association_assigned_code is not None:
            pulumi.set(__self__, "message_association_assigned_code", message_association_assigned_code)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if message_release is not None:
            pulumi.set(__self__, "message_release", message_release)
        if message_version is not None:
            pulumi.set(__self__, "message_version", message_version)
        if receiver_application_id is not None:
            pulumi.set(__self__, "receiver_application_id", receiver_application_id)
        if receiver_application_qualifier is not None:
            pulumi.set(__self__, "receiver_application_qualifier", receiver_application_qualifier)
        if sender_application_id is not None:
            pulumi.set(__self__, "sender_application_id", sender_application_id)
        if sender_application_qualifier is not None:
            pulumi.set(__self__, "sender_application_qualifier", sender_application_qualifier)
        if target_namespace is not None:
            pulumi.set(__self__, "target_namespace", target_namespace)

    @property
    @pulumi.getter(name="applicationPassword")
    def application_password(self) -> Optional[pulumi.Input[str]]:
        """
        The application password.
        """
        return pulumi.get(self, "application_password")

    @application_password.setter
    def application_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_password", value)

    @property
    @pulumi.getter(name="associationAssignedCode")
    def association_assigned_code(self) -> Optional[pulumi.Input[str]]:
        """
        The association assigned code.
        """
        return pulumi.get(self, "association_assigned_code")

    @association_assigned_code.setter
    def association_assigned_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "association_assigned_code", value)

    @property
    @pulumi.getter(name="controllingAgencyCode")
    def controlling_agency_code(self) -> Optional[pulumi.Input[str]]:
        """
        The controlling agency code.
        """
        return pulumi.get(self, "controlling_agency_code")

    @controlling_agency_code.setter
    def controlling_agency_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "controlling_agency_code", value)

    @property
    @pulumi.getter(name="functionalGroupId")
    def functional_group_id(self) -> Optional[pulumi.Input[str]]:
        """
        The functional group id.
        """
        return pulumi.get(self, "functional_group_id")

    @functional_group_id.setter
    def functional_group_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "functional_group_id", value)

    @property
    @pulumi.getter(name="groupHeaderMessageRelease")
    def group_header_message_release(self) -> Optional[pulumi.Input[str]]:
        """
        The group header message release.
        """
        return pulumi.get(self, "group_header_message_release")

    @group_header_message_release.setter
    def group_header_message_release(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_header_message_release", value)

    @property
    @pulumi.getter(name="groupHeaderMessageVersion")
    def group_header_message_version(self) -> Optional[pulumi.Input[str]]:
        """
        The group header message version.
        """
        return pulumi.get(self, "group_header_message_version")

    @group_header_message_version.setter
    def group_header_message_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_header_message_version", value)

    @property
    @pulumi.getter(name="messageAssociationAssignedCode")
    def message_association_assigned_code(self) -> Optional[pulumi.Input[str]]:
        """
        The message association assigned code.
        """
        return pulumi.get(self, "message_association_assigned_code")

    @message_association_assigned_code.setter
    def message_association_assigned_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_association_assigned_code", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="messageRelease")
    def message_release(self) -> Optional[pulumi.Input[str]]:
        """
        The message release version on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "message_release")

    @message_release.setter
    def message_release(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_release", value)

    @property
    @pulumi.getter(name="messageVersion")
    def message_version(self) -> Optional[pulumi.Input[str]]:
        """
        The message version on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "message_version")

    @message_version.setter
    def message_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_version", value)

    @property
    @pulumi.getter(name="receiverApplicationId")
    def receiver_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver application id.
        """
        return pulumi.get(self, "receiver_application_id")

    @receiver_application_id.setter
    def receiver_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_application_id", value)

    @property
    @pulumi.getter(name="receiverApplicationQualifier")
    def receiver_application_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver application qualifier.
        """
        return pulumi.get(self, "receiver_application_qualifier")

    @receiver_application_qualifier.setter
    def receiver_application_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_application_qualifier", value)

    @property
    @pulumi.getter(name="senderApplicationId")
    def sender_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application id.
        """
        return pulumi.get(self, "sender_application_id")

    @sender_application_id.setter
    def sender_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_id", value)

    @property
    @pulumi.getter(name="senderApplicationQualifier")
    def sender_application_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application qualifier.
        """
        return pulumi.get(self, "sender_application_qualifier")

    @sender_application_qualifier.setter
    def sender_application_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_qualifier", value)

    @property
    @pulumi.getter(name="targetNamespace")
    def target_namespace(self) -> Optional[pulumi.Input[str]]:
        """
        The target namespace on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "target_namespace")

    @target_namespace.setter
    def target_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_namespace", value)


@pulumi.input_type
class EdifactEnvelopeSettingsArgs:
    def __init__(__self__, *,
                 application_reference_id: Optional[pulumi.Input[str]] = None,
                 apply_delimiter_string_advice: Optional[pulumi.Input[bool]] = None,
                 communication_agreement_id: Optional[pulumi.Input[str]] = None,
                 create_grouping_segments: Optional[pulumi.Input[bool]] = None,
                 enable_default_group_headers: Optional[pulumi.Input[bool]] = None,
                 functional_group_id: Optional[pulumi.Input[str]] = None,
                 group_application_password: Optional[pulumi.Input[str]] = None,
                 group_application_receiver_id: Optional[pulumi.Input[str]] = None,
                 group_application_receiver_qualifier: Optional[pulumi.Input[str]] = None,
                 group_application_sender_id: Optional[pulumi.Input[str]] = None,
                 group_application_sender_qualifier: Optional[pulumi.Input[str]] = None,
                 group_association_assigned_code: Optional[pulumi.Input[str]] = None,
                 group_control_number_lower_bound: Optional[pulumi.Input[float]] = None,
                 group_control_number_prefix: Optional[pulumi.Input[str]] = None,
                 group_control_number_suffix: Optional[pulumi.Input[str]] = None,
                 group_control_number_upper_bound: Optional[pulumi.Input[float]] = None,
                 group_controlling_agency_code: Optional[pulumi.Input[str]] = None,
                 group_message_release: Optional[pulumi.Input[str]] = None,
                 group_message_version: Optional[pulumi.Input[str]] = None,
                 interchange_control_number_lower_bound: Optional[pulumi.Input[float]] = None,
                 interchange_control_number_prefix: Optional[pulumi.Input[str]] = None,
                 interchange_control_number_suffix: Optional[pulumi.Input[str]] = None,
                 interchange_control_number_upper_bound: Optional[pulumi.Input[float]] = None,
                 is_test_interchange: Optional[pulumi.Input[bool]] = None,
                 overwrite_existing_transaction_set_control_number: Optional[pulumi.Input[bool]] = None,
                 processing_priority_code: Optional[pulumi.Input[str]] = None,
                 receiver_internal_identification: Optional[pulumi.Input[str]] = None,
                 receiver_internal_sub_identification: Optional[pulumi.Input[str]] = None,
                 receiver_reverse_routing_address: Optional[pulumi.Input[str]] = None,
                 recipient_reference_password_qualifier: Optional[pulumi.Input[str]] = None,
                 recipient_reference_password_value: Optional[pulumi.Input[str]] = None,
                 rollover_group_control_number: Optional[pulumi.Input[bool]] = None,
                 rollover_interchange_control_number: Optional[pulumi.Input[bool]] = None,
                 rollover_transaction_set_control_number: Optional[pulumi.Input[bool]] = None,
                 sender_internal_identification: Optional[pulumi.Input[str]] = None,
                 sender_internal_sub_identification: Optional[pulumi.Input[str]] = None,
                 sender_reverse_routing_address: Optional[pulumi.Input[str]] = None,
                 transaction_set_control_number_lower_bound: Optional[pulumi.Input[float]] = None,
                 transaction_set_control_number_prefix: Optional[pulumi.Input[str]] = None,
                 transaction_set_control_number_suffix: Optional[pulumi.Input[str]] = None,
                 transaction_set_control_number_upper_bound: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] application_reference_id: The application reference id.
        :param pulumi.Input[bool] apply_delimiter_string_advice: The value indicating whether to apply delimiter string advice.
        :param pulumi.Input[str] communication_agreement_id: The communication agreement id.
        :param pulumi.Input[bool] create_grouping_segments: The value indicating whether to create grouping segments.
        :param pulumi.Input[bool] enable_default_group_headers: The value indicating whether to enable default group headers.
        :param pulumi.Input[str] functional_group_id: The functional group id.
        :param pulumi.Input[str] group_application_password: The group application password.
        :param pulumi.Input[str] group_application_receiver_id: The group application receiver id.
        :param pulumi.Input[str] group_application_receiver_qualifier: The group application receiver qualifier.
        :param pulumi.Input[str] group_application_sender_id: The group application sender id.
        :param pulumi.Input[str] group_application_sender_qualifier: The group application sender qualifier.
        :param pulumi.Input[str] group_association_assigned_code: The group association assigned code.
        :param pulumi.Input[float] group_control_number_lower_bound: The group control number lower bound.
        :param pulumi.Input[str] group_control_number_prefix: The group control number prefix.
        :param pulumi.Input[str] group_control_number_suffix: The group control number suffix.
        :param pulumi.Input[float] group_control_number_upper_bound: The group control number upper bound.
        :param pulumi.Input[str] group_controlling_agency_code: The group controlling agency code.
        :param pulumi.Input[str] group_message_release: The group message release.
        :param pulumi.Input[str] group_message_version: The group message version.
        :param pulumi.Input[float] interchange_control_number_lower_bound: The interchange control number lower bound.
        :param pulumi.Input[str] interchange_control_number_prefix: The interchange control number prefix.
        :param pulumi.Input[str] interchange_control_number_suffix: The interchange control number suffix.
        :param pulumi.Input[float] interchange_control_number_upper_bound: The interchange control number upper bound.
        :param pulumi.Input[bool] is_test_interchange: The value indicating whether the message is a test interchange.
        :param pulumi.Input[bool] overwrite_existing_transaction_set_control_number: The value indicating whether to overwrite existing transaction set control number.
        :param pulumi.Input[str] processing_priority_code: The processing priority code.
        :param pulumi.Input[str] receiver_internal_identification: The receiver internal identification.
        :param pulumi.Input[str] receiver_internal_sub_identification: The receiver internal sub identification.
        :param pulumi.Input[str] receiver_reverse_routing_address: The receiver reverse routing address.
        :param pulumi.Input[str] recipient_reference_password_qualifier: The recipient reference password qualifier.
        :param pulumi.Input[str] recipient_reference_password_value: The recipient reference password value.
        :param pulumi.Input[bool] rollover_group_control_number: The value indicating whether to rollover group control number.
        :param pulumi.Input[bool] rollover_interchange_control_number: The value indicating whether to rollover interchange control number.
        :param pulumi.Input[bool] rollover_transaction_set_control_number: The value indicating whether to rollover transaction set control number.
        :param pulumi.Input[str] sender_internal_identification: The sender internal identification.
        :param pulumi.Input[str] sender_internal_sub_identification: The sender internal sub identification.
        :param pulumi.Input[str] sender_reverse_routing_address: The sender reverse routing address.
        :param pulumi.Input[float] transaction_set_control_number_lower_bound: The transaction set control number lower bound.
        :param pulumi.Input[str] transaction_set_control_number_prefix: The transaction set control number prefix.
        :param pulumi.Input[str] transaction_set_control_number_suffix: The transaction set control number suffix.
        :param pulumi.Input[float] transaction_set_control_number_upper_bound: The transaction set control number upper bound.
        """
        if application_reference_id is not None:
            pulumi.set(__self__, "application_reference_id", application_reference_id)
        if apply_delimiter_string_advice is not None:
            pulumi.set(__self__, "apply_delimiter_string_advice", apply_delimiter_string_advice)
        if communication_agreement_id is not None:
            pulumi.set(__self__, "communication_agreement_id", communication_agreement_id)
        if create_grouping_segments is not None:
            pulumi.set(__self__, "create_grouping_segments", create_grouping_segments)
        if enable_default_group_headers is not None:
            pulumi.set(__self__, "enable_default_group_headers", enable_default_group_headers)
        if functional_group_id is not None:
            pulumi.set(__self__, "functional_group_id", functional_group_id)
        if group_application_password is not None:
            pulumi.set(__self__, "group_application_password", group_application_password)
        if group_application_receiver_id is not None:
            pulumi.set(__self__, "group_application_receiver_id", group_application_receiver_id)
        if group_application_receiver_qualifier is not None:
            pulumi.set(__self__, "group_application_receiver_qualifier", group_application_receiver_qualifier)
        if group_application_sender_id is not None:
            pulumi.set(__self__, "group_application_sender_id", group_application_sender_id)
        if group_application_sender_qualifier is not None:
            pulumi.set(__self__, "group_application_sender_qualifier", group_application_sender_qualifier)
        if group_association_assigned_code is not None:
            pulumi.set(__self__, "group_association_assigned_code", group_association_assigned_code)
        if group_control_number_lower_bound is not None:
            pulumi.set(__self__, "group_control_number_lower_bound", group_control_number_lower_bound)
        if group_control_number_prefix is not None:
            pulumi.set(__self__, "group_control_number_prefix", group_control_number_prefix)
        if group_control_number_suffix is not None:
            pulumi.set(__self__, "group_control_number_suffix", group_control_number_suffix)
        if group_control_number_upper_bound is not None:
            pulumi.set(__self__, "group_control_number_upper_bound", group_control_number_upper_bound)
        if group_controlling_agency_code is not None:
            pulumi.set(__self__, "group_controlling_agency_code", group_controlling_agency_code)
        if group_message_release is not None:
            pulumi.set(__self__, "group_message_release", group_message_release)
        if group_message_version is not None:
            pulumi.set(__self__, "group_message_version", group_message_version)
        if interchange_control_number_lower_bound is not None:
            pulumi.set(__self__, "interchange_control_number_lower_bound", interchange_control_number_lower_bound)
        if interchange_control_number_prefix is not None:
            pulumi.set(__self__, "interchange_control_number_prefix", interchange_control_number_prefix)
        if interchange_control_number_suffix is not None:
            pulumi.set(__self__, "interchange_control_number_suffix", interchange_control_number_suffix)
        if interchange_control_number_upper_bound is not None:
            pulumi.set(__self__, "interchange_control_number_upper_bound", interchange_control_number_upper_bound)
        if is_test_interchange is not None:
            pulumi.set(__self__, "is_test_interchange", is_test_interchange)
        if overwrite_existing_transaction_set_control_number is not None:
            pulumi.set(__self__, "overwrite_existing_transaction_set_control_number", overwrite_existing_transaction_set_control_number)
        if processing_priority_code is not None:
            pulumi.set(__self__, "processing_priority_code", processing_priority_code)
        if receiver_internal_identification is not None:
            pulumi.set(__self__, "receiver_internal_identification", receiver_internal_identification)
        if receiver_internal_sub_identification is not None:
            pulumi.set(__self__, "receiver_internal_sub_identification", receiver_internal_sub_identification)
        if receiver_reverse_routing_address is not None:
            pulumi.set(__self__, "receiver_reverse_routing_address", receiver_reverse_routing_address)
        if recipient_reference_password_qualifier is not None:
            pulumi.set(__self__, "recipient_reference_password_qualifier", recipient_reference_password_qualifier)
        if recipient_reference_password_value is not None:
            pulumi.set(__self__, "recipient_reference_password_value", recipient_reference_password_value)
        if rollover_group_control_number is not None:
            pulumi.set(__self__, "rollover_group_control_number", rollover_group_control_number)
        if rollover_interchange_control_number is not None:
            pulumi.set(__self__, "rollover_interchange_control_number", rollover_interchange_control_number)
        if rollover_transaction_set_control_number is not None:
            pulumi.set(__self__, "rollover_transaction_set_control_number", rollover_transaction_set_control_number)
        if sender_internal_identification is not None:
            pulumi.set(__self__, "sender_internal_identification", sender_internal_identification)
        if sender_internal_sub_identification is not None:
            pulumi.set(__self__, "sender_internal_sub_identification", sender_internal_sub_identification)
        if sender_reverse_routing_address is not None:
            pulumi.set(__self__, "sender_reverse_routing_address", sender_reverse_routing_address)
        if transaction_set_control_number_lower_bound is not None:
            pulumi.set(__self__, "transaction_set_control_number_lower_bound", transaction_set_control_number_lower_bound)
        if transaction_set_control_number_prefix is not None:
            pulumi.set(__self__, "transaction_set_control_number_prefix", transaction_set_control_number_prefix)
        if transaction_set_control_number_suffix is not None:
            pulumi.set(__self__, "transaction_set_control_number_suffix", transaction_set_control_number_suffix)
        if transaction_set_control_number_upper_bound is not None:
            pulumi.set(__self__, "transaction_set_control_number_upper_bound", transaction_set_control_number_upper_bound)

    @property
    @pulumi.getter(name="applicationReferenceId")
    def application_reference_id(self) -> Optional[pulumi.Input[str]]:
        """
        The application reference id.
        """
        return pulumi.get(self, "application_reference_id")

    @application_reference_id.setter
    def application_reference_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_reference_id", value)

    @property
    @pulumi.getter(name="applyDelimiterStringAdvice")
    def apply_delimiter_string_advice(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to apply delimiter string advice.
        """
        return pulumi.get(self, "apply_delimiter_string_advice")

    @apply_delimiter_string_advice.setter
    def apply_delimiter_string_advice(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "apply_delimiter_string_advice", value)

    @property
    @pulumi.getter(name="communicationAgreementId")
    def communication_agreement_id(self) -> Optional[pulumi.Input[str]]:
        """
        The communication agreement id.
        """
        return pulumi.get(self, "communication_agreement_id")

    @communication_agreement_id.setter
    def communication_agreement_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "communication_agreement_id", value)

    @property
    @pulumi.getter(name="createGroupingSegments")
    def create_grouping_segments(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to create grouping segments.
        """
        return pulumi.get(self, "create_grouping_segments")

    @create_grouping_segments.setter
    def create_grouping_segments(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_grouping_segments", value)

    @property
    @pulumi.getter(name="enableDefaultGroupHeaders")
    def enable_default_group_headers(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable default group headers.
        """
        return pulumi.get(self, "enable_default_group_headers")

    @enable_default_group_headers.setter
    def enable_default_group_headers(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_default_group_headers", value)

    @property
    @pulumi.getter(name="functionalGroupId")
    def functional_group_id(self) -> Optional[pulumi.Input[str]]:
        """
        The functional group id.
        """
        return pulumi.get(self, "functional_group_id")

    @functional_group_id.setter
    def functional_group_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "functional_group_id", value)

    @property
    @pulumi.getter(name="groupApplicationPassword")
    def group_application_password(self) -> Optional[pulumi.Input[str]]:
        """
        The group application password.
        """
        return pulumi.get(self, "group_application_password")

    @group_application_password.setter
    def group_application_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_application_password", value)

    @property
    @pulumi.getter(name="groupApplicationReceiverId")
    def group_application_receiver_id(self) -> Optional[pulumi.Input[str]]:
        """
        The group application receiver id.
        """
        return pulumi.get(self, "group_application_receiver_id")

    @group_application_receiver_id.setter
    def group_application_receiver_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_application_receiver_id", value)

    @property
    @pulumi.getter(name="groupApplicationReceiverQualifier")
    def group_application_receiver_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The group application receiver qualifier.
        """
        return pulumi.get(self, "group_application_receiver_qualifier")

    @group_application_receiver_qualifier.setter
    def group_application_receiver_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_application_receiver_qualifier", value)

    @property
    @pulumi.getter(name="groupApplicationSenderId")
    def group_application_sender_id(self) -> Optional[pulumi.Input[str]]:
        """
        The group application sender id.
        """
        return pulumi.get(self, "group_application_sender_id")

    @group_application_sender_id.setter
    def group_application_sender_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_application_sender_id", value)

    @property
    @pulumi.getter(name="groupApplicationSenderQualifier")
    def group_application_sender_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The group application sender qualifier.
        """
        return pulumi.get(self, "group_application_sender_qualifier")

    @group_application_sender_qualifier.setter
    def group_application_sender_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_application_sender_qualifier", value)

    @property
    @pulumi.getter(name="groupAssociationAssignedCode")
    def group_association_assigned_code(self) -> Optional[pulumi.Input[str]]:
        """
        The group association assigned code.
        """
        return pulumi.get(self, "group_association_assigned_code")

    @group_association_assigned_code.setter
    def group_association_assigned_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_association_assigned_code", value)

    @property
    @pulumi.getter(name="groupControlNumberLowerBound")
    def group_control_number_lower_bound(self) -> Optional[pulumi.Input[float]]:
        """
        The group control number lower bound.
        """
        return pulumi.get(self, "group_control_number_lower_bound")

    @group_control_number_lower_bound.setter
    def group_control_number_lower_bound(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "group_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="groupControlNumberPrefix")
    def group_control_number_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The group control number prefix.
        """
        return pulumi.get(self, "group_control_number_prefix")

    @group_control_number_prefix.setter
    def group_control_number_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_control_number_prefix", value)

    @property
    @pulumi.getter(name="groupControlNumberSuffix")
    def group_control_number_suffix(self) -> Optional[pulumi.Input[str]]:
        """
        The group control number suffix.
        """
        return pulumi.get(self, "group_control_number_suffix")

    @group_control_number_suffix.setter
    def group_control_number_suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_control_number_suffix", value)

    @property
    @pulumi.getter(name="groupControlNumberUpperBound")
    def group_control_number_upper_bound(self) -> Optional[pulumi.Input[float]]:
        """
        The group control number upper bound.
        """
        return pulumi.get(self, "group_control_number_upper_bound")

    @group_control_number_upper_bound.setter
    def group_control_number_upper_bound(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "group_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="groupControllingAgencyCode")
    def group_controlling_agency_code(self) -> Optional[pulumi.Input[str]]:
        """
        The group controlling agency code.
        """
        return pulumi.get(self, "group_controlling_agency_code")

    @group_controlling_agency_code.setter
    def group_controlling_agency_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_controlling_agency_code", value)

    @property
    @pulumi.getter(name="groupMessageRelease")
    def group_message_release(self) -> Optional[pulumi.Input[str]]:
        """
        The group message release.
        """
        return pulumi.get(self, "group_message_release")

    @group_message_release.setter
    def group_message_release(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_message_release", value)

    @property
    @pulumi.getter(name="groupMessageVersion")
    def group_message_version(self) -> Optional[pulumi.Input[str]]:
        """
        The group message version.
        """
        return pulumi.get(self, "group_message_version")

    @group_message_version.setter
    def group_message_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_message_version", value)

    @property
    @pulumi.getter(name="interchangeControlNumberLowerBound")
    def interchange_control_number_lower_bound(self) -> Optional[pulumi.Input[float]]:
        """
        The interchange control number lower bound.
        """
        return pulumi.get(self, "interchange_control_number_lower_bound")

    @interchange_control_number_lower_bound.setter
    def interchange_control_number_lower_bound(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "interchange_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="interchangeControlNumberPrefix")
    def interchange_control_number_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The interchange control number prefix.
        """
        return pulumi.get(self, "interchange_control_number_prefix")

    @interchange_control_number_prefix.setter
    def interchange_control_number_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interchange_control_number_prefix", value)

    @property
    @pulumi.getter(name="interchangeControlNumberSuffix")
    def interchange_control_number_suffix(self) -> Optional[pulumi.Input[str]]:
        """
        The interchange control number suffix.
        """
        return pulumi.get(self, "interchange_control_number_suffix")

    @interchange_control_number_suffix.setter
    def interchange_control_number_suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interchange_control_number_suffix", value)

    @property
    @pulumi.getter(name="interchangeControlNumberUpperBound")
    def interchange_control_number_upper_bound(self) -> Optional[pulumi.Input[float]]:
        """
        The interchange control number upper bound.
        """
        return pulumi.get(self, "interchange_control_number_upper_bound")

    @interchange_control_number_upper_bound.setter
    def interchange_control_number_upper_bound(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "interchange_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="isTestInterchange")
    def is_test_interchange(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether the message is a test interchange.
        """
        return pulumi.get(self, "is_test_interchange")

    @is_test_interchange.setter
    def is_test_interchange(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_test_interchange", value)

    @property
    @pulumi.getter(name="overwriteExistingTransactionSetControlNumber")
    def overwrite_existing_transaction_set_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to overwrite existing transaction set control number.
        """
        return pulumi.get(self, "overwrite_existing_transaction_set_control_number")

    @overwrite_existing_transaction_set_control_number.setter
    def overwrite_existing_transaction_set_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "overwrite_existing_transaction_set_control_number", value)

    @property
    @pulumi.getter(name="processingPriorityCode")
    def processing_priority_code(self) -> Optional[pulumi.Input[str]]:
        """
        The processing priority code.
        """
        return pulumi.get(self, "processing_priority_code")

    @processing_priority_code.setter
    def processing_priority_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "processing_priority_code", value)

    @property
    @pulumi.getter(name="receiverInternalIdentification")
    def receiver_internal_identification(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver internal identification.
        """
        return pulumi.get(self, "receiver_internal_identification")

    @receiver_internal_identification.setter
    def receiver_internal_identification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_internal_identification", value)

    @property
    @pulumi.getter(name="receiverInternalSubIdentification")
    def receiver_internal_sub_identification(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver internal sub identification.
        """
        return pulumi.get(self, "receiver_internal_sub_identification")

    @receiver_internal_sub_identification.setter
    def receiver_internal_sub_identification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_internal_sub_identification", value)

    @property
    @pulumi.getter(name="receiverReverseRoutingAddress")
    def receiver_reverse_routing_address(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver reverse routing address.
        """
        return pulumi.get(self, "receiver_reverse_routing_address")

    @receiver_reverse_routing_address.setter
    def receiver_reverse_routing_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_reverse_routing_address", value)

    @property
    @pulumi.getter(name="recipientReferencePasswordQualifier")
    def recipient_reference_password_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The recipient reference password qualifier.
        """
        return pulumi.get(self, "recipient_reference_password_qualifier")

    @recipient_reference_password_qualifier.setter
    def recipient_reference_password_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recipient_reference_password_qualifier", value)

    @property
    @pulumi.getter(name="recipientReferencePasswordValue")
    def recipient_reference_password_value(self) -> Optional[pulumi.Input[str]]:
        """
        The recipient reference password value.
        """
        return pulumi.get(self, "recipient_reference_password_value")

    @recipient_reference_password_value.setter
    def recipient_reference_password_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recipient_reference_password_value", value)

    @property
    @pulumi.getter(name="rolloverGroupControlNumber")
    def rollover_group_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover group control number.
        """
        return pulumi.get(self, "rollover_group_control_number")

    @rollover_group_control_number.setter
    def rollover_group_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_group_control_number", value)

    @property
    @pulumi.getter(name="rolloverInterchangeControlNumber")
    def rollover_interchange_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover interchange control number.
        """
        return pulumi.get(self, "rollover_interchange_control_number")

    @rollover_interchange_control_number.setter
    def rollover_interchange_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_interchange_control_number", value)

    @property
    @pulumi.getter(name="rolloverTransactionSetControlNumber")
    def rollover_transaction_set_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover transaction set control number.
        """
        return pulumi.get(self, "rollover_transaction_set_control_number")

    @rollover_transaction_set_control_number.setter
    def rollover_transaction_set_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_transaction_set_control_number", value)

    @property
    @pulumi.getter(name="senderInternalIdentification")
    def sender_internal_identification(self) -> Optional[pulumi.Input[str]]:
        """
        The sender internal identification.
        """
        return pulumi.get(self, "sender_internal_identification")

    @sender_internal_identification.setter
    def sender_internal_identification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_internal_identification", value)

    @property
    @pulumi.getter(name="senderInternalSubIdentification")
    def sender_internal_sub_identification(self) -> Optional[pulumi.Input[str]]:
        """
        The sender internal sub identification.
        """
        return pulumi.get(self, "sender_internal_sub_identification")

    @sender_internal_sub_identification.setter
    def sender_internal_sub_identification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_internal_sub_identification", value)

    @property
    @pulumi.getter(name="senderReverseRoutingAddress")
    def sender_reverse_routing_address(self) -> Optional[pulumi.Input[str]]:
        """
        The sender reverse routing address.
        """
        return pulumi.get(self, "sender_reverse_routing_address")

    @sender_reverse_routing_address.setter
    def sender_reverse_routing_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_reverse_routing_address", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberLowerBound")
    def transaction_set_control_number_lower_bound(self) -> Optional[pulumi.Input[float]]:
        """
        The transaction set control number lower bound.
        """
        return pulumi.get(self, "transaction_set_control_number_lower_bound")

    @transaction_set_control_number_lower_bound.setter
    def transaction_set_control_number_lower_bound(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "transaction_set_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberPrefix")
    def transaction_set_control_number_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The transaction set control number prefix.
        """
        return pulumi.get(self, "transaction_set_control_number_prefix")

    @transaction_set_control_number_prefix.setter
    def transaction_set_control_number_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "transaction_set_control_number_prefix", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberSuffix")
    def transaction_set_control_number_suffix(self) -> Optional[pulumi.Input[str]]:
        """
        The transaction set control number suffix.
        """
        return pulumi.get(self, "transaction_set_control_number_suffix")

    @transaction_set_control_number_suffix.setter
    def transaction_set_control_number_suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "transaction_set_control_number_suffix", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberUpperBound")
    def transaction_set_control_number_upper_bound(self) -> Optional[pulumi.Input[float]]:
        """
        The transaction set control number upper bound.
        """
        return pulumi.get(self, "transaction_set_control_number_upper_bound")

    @transaction_set_control_number_upper_bound.setter
    def transaction_set_control_number_upper_bound(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "transaction_set_control_number_upper_bound", value)


@pulumi.input_type
class EdifactFramingSettingsArgs:
    def __init__(__self__, *,
                 character_encoding: Optional[pulumi.Input[str]] = None,
                 character_set: Optional[pulumi.Input['EdifactCharacterSet']] = None,
                 component_separator: Optional[pulumi.Input[int]] = None,
                 data_element_separator: Optional[pulumi.Input[int]] = None,
                 decimal_point_indicator: Optional[pulumi.Input['EdifactDecimalIndicator']] = None,
                 protocol_version: Optional[pulumi.Input[int]] = None,
                 release_indicator: Optional[pulumi.Input[int]] = None,
                 repetition_separator: Optional[pulumi.Input[int]] = None,
                 segment_terminator: Optional[pulumi.Input[int]] = None,
                 segment_terminator_suffix: Optional[pulumi.Input['SegmentTerminatorSuffix']] = None,
                 service_code_list_directory_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] character_encoding: The character encoding.
        :param pulumi.Input['EdifactCharacterSet'] character_set: The EDIFACT frame setting characterSet.
        :param pulumi.Input[int] component_separator: The component separator.
        :param pulumi.Input[int] data_element_separator: The data element separator.
        :param pulumi.Input['EdifactDecimalIndicator'] decimal_point_indicator: The EDIFACT frame setting decimal indicator.
        :param pulumi.Input[int] protocol_version: The protocol version.
        :param pulumi.Input[int] release_indicator: The release indicator.
        :param pulumi.Input[int] repetition_separator: The repetition separator.
        :param pulumi.Input[int] segment_terminator: The segment terminator.
        :param pulumi.Input['SegmentTerminatorSuffix'] segment_terminator_suffix: The EDIFACT frame setting segment terminator suffix.
        :param pulumi.Input[str] service_code_list_directory_version: The service code list directory version.
        """
        if character_encoding is not None:
            pulumi.set(__self__, "character_encoding", character_encoding)
        if character_set is not None:
            pulumi.set(__self__, "character_set", character_set)
        if component_separator is not None:
            pulumi.set(__self__, "component_separator", component_separator)
        if data_element_separator is not None:
            pulumi.set(__self__, "data_element_separator", data_element_separator)
        if decimal_point_indicator is not None:
            pulumi.set(__self__, "decimal_point_indicator", decimal_point_indicator)
        if protocol_version is not None:
            pulumi.set(__self__, "protocol_version", protocol_version)
        if release_indicator is not None:
            pulumi.set(__self__, "release_indicator", release_indicator)
        if repetition_separator is not None:
            pulumi.set(__self__, "repetition_separator", repetition_separator)
        if segment_terminator is not None:
            pulumi.set(__self__, "segment_terminator", segment_terminator)
        if segment_terminator_suffix is not None:
            pulumi.set(__self__, "segment_terminator_suffix", segment_terminator_suffix)
        if service_code_list_directory_version is not None:
            pulumi.set(__self__, "service_code_list_directory_version", service_code_list_directory_version)

    @property
    @pulumi.getter(name="characterEncoding")
    def character_encoding(self) -> Optional[pulumi.Input[str]]:
        """
        The character encoding.
        """
        return pulumi.get(self, "character_encoding")

    @character_encoding.setter
    def character_encoding(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "character_encoding", value)

    @property
    @pulumi.getter(name="characterSet")
    def character_set(self) -> Optional[pulumi.Input['EdifactCharacterSet']]:
        """
        The EDIFACT frame setting characterSet.
        """
        return pulumi.get(self, "character_set")

    @character_set.setter
    def character_set(self, value: Optional[pulumi.Input['EdifactCharacterSet']]):
        pulumi.set(self, "character_set", value)

    @property
    @pulumi.getter(name="componentSeparator")
    def component_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The component separator.
        """
        return pulumi.get(self, "component_separator")

    @component_separator.setter
    def component_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "component_separator", value)

    @property
    @pulumi.getter(name="dataElementSeparator")
    def data_element_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The data element separator.
        """
        return pulumi.get(self, "data_element_separator")

    @data_element_separator.setter
    def data_element_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "data_element_separator", value)

    @property
    @pulumi.getter(name="decimalPointIndicator")
    def decimal_point_indicator(self) -> Optional[pulumi.Input['EdifactDecimalIndicator']]:
        """
        The EDIFACT frame setting decimal indicator.
        """
        return pulumi.get(self, "decimal_point_indicator")

    @decimal_point_indicator.setter
    def decimal_point_indicator(self, value: Optional[pulumi.Input['EdifactDecimalIndicator']]):
        pulumi.set(self, "decimal_point_indicator", value)

    @property
    @pulumi.getter(name="protocolVersion")
    def protocol_version(self) -> Optional[pulumi.Input[int]]:
        """
        The protocol version.
        """
        return pulumi.get(self, "protocol_version")

    @protocol_version.setter
    def protocol_version(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "protocol_version", value)

    @property
    @pulumi.getter(name="releaseIndicator")
    def release_indicator(self) -> Optional[pulumi.Input[int]]:
        """
        The release indicator.
        """
        return pulumi.get(self, "release_indicator")

    @release_indicator.setter
    def release_indicator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "release_indicator", value)

    @property
    @pulumi.getter(name="repetitionSeparator")
    def repetition_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The repetition separator.
        """
        return pulumi.get(self, "repetition_separator")

    @repetition_separator.setter
    def repetition_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "repetition_separator", value)

    @property
    @pulumi.getter(name="segmentTerminator")
    def segment_terminator(self) -> Optional[pulumi.Input[int]]:
        """
        The segment terminator.
        """
        return pulumi.get(self, "segment_terminator")

    @segment_terminator.setter
    def segment_terminator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "segment_terminator", value)

    @property
    @pulumi.getter(name="segmentTerminatorSuffix")
    def segment_terminator_suffix(self) -> Optional[pulumi.Input['SegmentTerminatorSuffix']]:
        """
        The EDIFACT frame setting segment terminator suffix.
        """
        return pulumi.get(self, "segment_terminator_suffix")

    @segment_terminator_suffix.setter
    def segment_terminator_suffix(self, value: Optional[pulumi.Input['SegmentTerminatorSuffix']]):
        pulumi.set(self, "segment_terminator_suffix", value)

    @property
    @pulumi.getter(name="serviceCodeListDirectoryVersion")
    def service_code_list_directory_version(self) -> Optional[pulumi.Input[str]]:
        """
        The service code list directory version.
        """
        return pulumi.get(self, "service_code_list_directory_version")

    @service_code_list_directory_version.setter
    def service_code_list_directory_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_code_list_directory_version", value)


@pulumi.input_type
class EdifactMessageFilterArgs:
    def __init__(__self__, *,
                 message_filter_type: Optional[pulumi.Input['MessageFilterType']] = None):
        """
        :param pulumi.Input['MessageFilterType'] message_filter_type: The message filter type.
        """
        if message_filter_type is not None:
            pulumi.set(__self__, "message_filter_type", message_filter_type)

    @property
    @pulumi.getter(name="messageFilterType")
    def message_filter_type(self) -> Optional[pulumi.Input['MessageFilterType']]:
        """
        The message filter type.
        """
        return pulumi.get(self, "message_filter_type")

    @message_filter_type.setter
    def message_filter_type(self, value: Optional[pulumi.Input['MessageFilterType']]):
        pulumi.set(self, "message_filter_type", value)


@pulumi.input_type
class EdifactMessageIdentifierArgs:
    def __init__(__self__, *,
                 message_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] message_id: The message id on which this envelope settings has to be applied.
        """
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)


@pulumi.input_type
class EdifactOneWayAgreementArgs:
    def __init__(__self__, *,
                 protocol_settings: Optional[pulumi.Input['EdifactProtocolSettingsArgs']] = None,
                 receiver_business_identity: Optional[pulumi.Input['BusinessIdentityArgs']] = None,
                 sender_business_identity: Optional[pulumi.Input['BusinessIdentityArgs']] = None):
        """
        :param pulumi.Input['EdifactProtocolSettingsArgs'] protocol_settings: The EDIFACT protocol settings.
        :param pulumi.Input['BusinessIdentityArgs'] receiver_business_identity: The receiver business identity
        :param pulumi.Input['BusinessIdentityArgs'] sender_business_identity: The sender business identity
        """
        if protocol_settings is not None:
            pulumi.set(__self__, "protocol_settings", protocol_settings)
        if receiver_business_identity is not None:
            pulumi.set(__self__, "receiver_business_identity", receiver_business_identity)
        if sender_business_identity is not None:
            pulumi.set(__self__, "sender_business_identity", sender_business_identity)

    @property
    @pulumi.getter(name="protocolSettings")
    def protocol_settings(self) -> Optional[pulumi.Input['EdifactProtocolSettingsArgs']]:
        """
        The EDIFACT protocol settings.
        """
        return pulumi.get(self, "protocol_settings")

    @protocol_settings.setter
    def protocol_settings(self, value: Optional[pulumi.Input['EdifactProtocolSettingsArgs']]):
        pulumi.set(self, "protocol_settings", value)

    @property
    @pulumi.getter(name="receiverBusinessIdentity")
    def receiver_business_identity(self) -> Optional[pulumi.Input['BusinessIdentityArgs']]:
        """
        The receiver business identity
        """
        return pulumi.get(self, "receiver_business_identity")

    @receiver_business_identity.setter
    def receiver_business_identity(self, value: Optional[pulumi.Input['BusinessIdentityArgs']]):
        pulumi.set(self, "receiver_business_identity", value)

    @property
    @pulumi.getter(name="senderBusinessIdentity")
    def sender_business_identity(self) -> Optional[pulumi.Input['BusinessIdentityArgs']]:
        """
        The sender business identity
        """
        return pulumi.get(self, "sender_business_identity")

    @sender_business_identity.setter
    def sender_business_identity(self, value: Optional[pulumi.Input['BusinessIdentityArgs']]):
        pulumi.set(self, "sender_business_identity", value)


@pulumi.input_type
class EdifactProcessingSettingsArgs:
    def __init__(__self__, *,
                 create_empty_xml_tags_for_trailing_separators: Optional[pulumi.Input[bool]] = None,
                 mask_security_info: Optional[pulumi.Input[bool]] = None,
                 preserve_interchange: Optional[pulumi.Input[bool]] = None,
                 suspend_interchange_on_error: Optional[pulumi.Input[bool]] = None,
                 use_dot_as_decimal_separator: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] create_empty_xml_tags_for_trailing_separators: The value indicating whether to create empty xml tags for trailing separators.
        :param pulumi.Input[bool] mask_security_info: The value indicating whether to mask security information.
        :param pulumi.Input[bool] preserve_interchange: The value indicating whether to preserve interchange.
        :param pulumi.Input[bool] suspend_interchange_on_error: The value indicating whether to suspend interchange on error.
        :param pulumi.Input[bool] use_dot_as_decimal_separator: The value indicating whether to use dot as decimal separator.
        """
        if create_empty_xml_tags_for_trailing_separators is not None:
            pulumi.set(__self__, "create_empty_xml_tags_for_trailing_separators", create_empty_xml_tags_for_trailing_separators)
        if mask_security_info is not None:
            pulumi.set(__self__, "mask_security_info", mask_security_info)
        if preserve_interchange is not None:
            pulumi.set(__self__, "preserve_interchange", preserve_interchange)
        if suspend_interchange_on_error is not None:
            pulumi.set(__self__, "suspend_interchange_on_error", suspend_interchange_on_error)
        if use_dot_as_decimal_separator is not None:
            pulumi.set(__self__, "use_dot_as_decimal_separator", use_dot_as_decimal_separator)

    @property
    @pulumi.getter(name="createEmptyXmlTagsForTrailingSeparators")
    def create_empty_xml_tags_for_trailing_separators(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to create empty xml tags for trailing separators.
        """
        return pulumi.get(self, "create_empty_xml_tags_for_trailing_separators")

    @create_empty_xml_tags_for_trailing_separators.setter
    def create_empty_xml_tags_for_trailing_separators(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_empty_xml_tags_for_trailing_separators", value)

    @property
    @pulumi.getter(name="maskSecurityInfo")
    def mask_security_info(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to mask security information.
        """
        return pulumi.get(self, "mask_security_info")

    @mask_security_info.setter
    def mask_security_info(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mask_security_info", value)

    @property
    @pulumi.getter(name="preserveInterchange")
    def preserve_interchange(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to preserve interchange.
        """
        return pulumi.get(self, "preserve_interchange")

    @preserve_interchange.setter
    def preserve_interchange(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preserve_interchange", value)

    @property
    @pulumi.getter(name="suspendInterchangeOnError")
    def suspend_interchange_on_error(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to suspend interchange on error.
        """
        return pulumi.get(self, "suspend_interchange_on_error")

    @suspend_interchange_on_error.setter
    def suspend_interchange_on_error(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "suspend_interchange_on_error", value)

    @property
    @pulumi.getter(name="useDotAsDecimalSeparator")
    def use_dot_as_decimal_separator(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to use dot as decimal separator.
        """
        return pulumi.get(self, "use_dot_as_decimal_separator")

    @use_dot_as_decimal_separator.setter
    def use_dot_as_decimal_separator(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_dot_as_decimal_separator", value)


@pulumi.input_type
class EdifactProtocolSettingsArgs:
    def __init__(__self__, *,
                 acknowledgement_settings: Optional[pulumi.Input['EdifactAcknowledgementSettingsArgs']] = None,
                 edifact_delimiter_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactDelimiterOverrideArgs']]]] = None,
                 envelope_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactEnvelopeOverrideArgs']]]] = None,
                 envelope_settings: Optional[pulumi.Input['EdifactEnvelopeSettingsArgs']] = None,
                 framing_settings: Optional[pulumi.Input['EdifactFramingSettingsArgs']] = None,
                 message_filter: Optional[pulumi.Input['EdifactMessageFilterArgs']] = None,
                 message_filter_list: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactMessageIdentifierArgs']]]] = None,
                 processing_settings: Optional[pulumi.Input['EdifactProcessingSettingsArgs']] = None,
                 schema_references: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactSchemaReferenceArgs']]]] = None,
                 validation_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactValidationOverrideArgs']]]] = None,
                 validation_settings: Optional[pulumi.Input['EdifactValidationSettingsArgs']] = None):
        """
        :param pulumi.Input['EdifactAcknowledgementSettingsArgs'] acknowledgement_settings: The EDIFACT acknowledgement settings.
        :param pulumi.Input[Sequence[pulumi.Input['EdifactDelimiterOverrideArgs']]] edifact_delimiter_overrides: The EDIFACT delimiter override settings.
        :param pulumi.Input[Sequence[pulumi.Input['EdifactEnvelopeOverrideArgs']]] envelope_overrides: The EDIFACT envelope override settings.
        :param pulumi.Input['EdifactEnvelopeSettingsArgs'] envelope_settings: The EDIFACT envelope settings.
        :param pulumi.Input['EdifactFramingSettingsArgs'] framing_settings: The EDIFACT framing settings.
        :param pulumi.Input['EdifactMessageFilterArgs'] message_filter: The EDIFACT message filter.
        :param pulumi.Input[Sequence[pulumi.Input['EdifactMessageIdentifierArgs']]] message_filter_list: The EDIFACT message filter list.
        :param pulumi.Input['EdifactProcessingSettingsArgs'] processing_settings: The EDIFACT processing Settings.
        :param pulumi.Input[Sequence[pulumi.Input['EdifactSchemaReferenceArgs']]] schema_references: The EDIFACT schema references.
        :param pulumi.Input[Sequence[pulumi.Input['EdifactValidationOverrideArgs']]] validation_overrides: The EDIFACT validation override settings.
        :param pulumi.Input['EdifactValidationSettingsArgs'] validation_settings: The EDIFACT validation settings.
        """
        if acknowledgement_settings is not None:
            pulumi.set(__self__, "acknowledgement_settings", acknowledgement_settings)
        if edifact_delimiter_overrides is not None:
            pulumi.set(__self__, "edifact_delimiter_overrides", edifact_delimiter_overrides)
        if envelope_overrides is not None:
            pulumi.set(__self__, "envelope_overrides", envelope_overrides)
        if envelope_settings is not None:
            pulumi.set(__self__, "envelope_settings", envelope_settings)
        if framing_settings is not None:
            pulumi.set(__self__, "framing_settings", framing_settings)
        if message_filter is not None:
            pulumi.set(__self__, "message_filter", message_filter)
        if message_filter_list is not None:
            pulumi.set(__self__, "message_filter_list", message_filter_list)
        if processing_settings is not None:
            pulumi.set(__self__, "processing_settings", processing_settings)
        if schema_references is not None:
            pulumi.set(__self__, "schema_references", schema_references)
        if validation_overrides is not None:
            pulumi.set(__self__, "validation_overrides", validation_overrides)
        if validation_settings is not None:
            pulumi.set(__self__, "validation_settings", validation_settings)

    @property
    @pulumi.getter(name="acknowledgementSettings")
    def acknowledgement_settings(self) -> Optional[pulumi.Input['EdifactAcknowledgementSettingsArgs']]:
        """
        The EDIFACT acknowledgement settings.
        """
        return pulumi.get(self, "acknowledgement_settings")

    @acknowledgement_settings.setter
    def acknowledgement_settings(self, value: Optional[pulumi.Input['EdifactAcknowledgementSettingsArgs']]):
        pulumi.set(self, "acknowledgement_settings", value)

    @property
    @pulumi.getter(name="edifactDelimiterOverrides")
    def edifact_delimiter_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdifactDelimiterOverrideArgs']]]]:
        """
        The EDIFACT delimiter override settings.
        """
        return pulumi.get(self, "edifact_delimiter_overrides")

    @edifact_delimiter_overrides.setter
    def edifact_delimiter_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactDelimiterOverrideArgs']]]]):
        pulumi.set(self, "edifact_delimiter_overrides", value)

    @property
    @pulumi.getter(name="envelopeOverrides")
    def envelope_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdifactEnvelopeOverrideArgs']]]]:
        """
        The EDIFACT envelope override settings.
        """
        return pulumi.get(self, "envelope_overrides")

    @envelope_overrides.setter
    def envelope_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactEnvelopeOverrideArgs']]]]):
        pulumi.set(self, "envelope_overrides", value)

    @property
    @pulumi.getter(name="envelopeSettings")
    def envelope_settings(self) -> Optional[pulumi.Input['EdifactEnvelopeSettingsArgs']]:
        """
        The EDIFACT envelope settings.
        """
        return pulumi.get(self, "envelope_settings")

    @envelope_settings.setter
    def envelope_settings(self, value: Optional[pulumi.Input['EdifactEnvelopeSettingsArgs']]):
        pulumi.set(self, "envelope_settings", value)

    @property
    @pulumi.getter(name="framingSettings")
    def framing_settings(self) -> Optional[pulumi.Input['EdifactFramingSettingsArgs']]:
        """
        The EDIFACT framing settings.
        """
        return pulumi.get(self, "framing_settings")

    @framing_settings.setter
    def framing_settings(self, value: Optional[pulumi.Input['EdifactFramingSettingsArgs']]):
        pulumi.set(self, "framing_settings", value)

    @property
    @pulumi.getter(name="messageFilter")
    def message_filter(self) -> Optional[pulumi.Input['EdifactMessageFilterArgs']]:
        """
        The EDIFACT message filter.
        """
        return pulumi.get(self, "message_filter")

    @message_filter.setter
    def message_filter(self, value: Optional[pulumi.Input['EdifactMessageFilterArgs']]):
        pulumi.set(self, "message_filter", value)

    @property
    @pulumi.getter(name="messageFilterList")
    def message_filter_list(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdifactMessageIdentifierArgs']]]]:
        """
        The EDIFACT message filter list.
        """
        return pulumi.get(self, "message_filter_list")

    @message_filter_list.setter
    def message_filter_list(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactMessageIdentifierArgs']]]]):
        pulumi.set(self, "message_filter_list", value)

    @property
    @pulumi.getter(name="processingSettings")
    def processing_settings(self) -> Optional[pulumi.Input['EdifactProcessingSettingsArgs']]:
        """
        The EDIFACT processing Settings.
        """
        return pulumi.get(self, "processing_settings")

    @processing_settings.setter
    def processing_settings(self, value: Optional[pulumi.Input['EdifactProcessingSettingsArgs']]):
        pulumi.set(self, "processing_settings", value)

    @property
    @pulumi.getter(name="schemaReferences")
    def schema_references(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdifactSchemaReferenceArgs']]]]:
        """
        The EDIFACT schema references.
        """
        return pulumi.get(self, "schema_references")

    @schema_references.setter
    def schema_references(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactSchemaReferenceArgs']]]]):
        pulumi.set(self, "schema_references", value)

    @property
    @pulumi.getter(name="validationOverrides")
    def validation_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EdifactValidationOverrideArgs']]]]:
        """
        The EDIFACT validation override settings.
        """
        return pulumi.get(self, "validation_overrides")

    @validation_overrides.setter
    def validation_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['EdifactValidationOverrideArgs']]]]):
        pulumi.set(self, "validation_overrides", value)

    @property
    @pulumi.getter(name="validationSettings")
    def validation_settings(self) -> Optional[pulumi.Input['EdifactValidationSettingsArgs']]:
        """
        The EDIFACT validation settings.
        """
        return pulumi.get(self, "validation_settings")

    @validation_settings.setter
    def validation_settings(self, value: Optional[pulumi.Input['EdifactValidationSettingsArgs']]):
        pulumi.set(self, "validation_settings", value)


@pulumi.input_type
class EdifactSchemaReferenceArgs:
    def __init__(__self__, *,
                 association_assigned_code: Optional[pulumi.Input[str]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 message_release: Optional[pulumi.Input[str]] = None,
                 message_version: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None,
                 sender_application_id: Optional[pulumi.Input[str]] = None,
                 sender_application_qualifier: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] association_assigned_code: The association assigned code.
        :param pulumi.Input[str] message_id: The message id.
        :param pulumi.Input[str] message_release: The message release version.
        :param pulumi.Input[str] message_version: The message version.
        :param pulumi.Input[str] schema_name: The schema name.
        :param pulumi.Input[str] sender_application_id: The sender application id.
        :param pulumi.Input[str] sender_application_qualifier: The sender application qualifier.
        """
        if association_assigned_code is not None:
            pulumi.set(__self__, "association_assigned_code", association_assigned_code)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if message_release is not None:
            pulumi.set(__self__, "message_release", message_release)
        if message_version is not None:
            pulumi.set(__self__, "message_version", message_version)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if sender_application_id is not None:
            pulumi.set(__self__, "sender_application_id", sender_application_id)
        if sender_application_qualifier is not None:
            pulumi.set(__self__, "sender_application_qualifier", sender_application_qualifier)

    @property
    @pulumi.getter(name="associationAssignedCode")
    def association_assigned_code(self) -> Optional[pulumi.Input[str]]:
        """
        The association assigned code.
        """
        return pulumi.get(self, "association_assigned_code")

    @association_assigned_code.setter
    def association_assigned_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "association_assigned_code", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="messageRelease")
    def message_release(self) -> Optional[pulumi.Input[str]]:
        """
        The message release version.
        """
        return pulumi.get(self, "message_release")

    @message_release.setter
    def message_release(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_release", value)

    @property
    @pulumi.getter(name="messageVersion")
    def message_version(self) -> Optional[pulumi.Input[str]]:
        """
        The message version.
        """
        return pulumi.get(self, "message_version")

    @message_version.setter
    def message_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_version", value)

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[pulumi.Input[str]]:
        """
        The schema name.
        """
        return pulumi.get(self, "schema_name")

    @schema_name.setter
    def schema_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schema_name", value)

    @property
    @pulumi.getter(name="senderApplicationId")
    def sender_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application id.
        """
        return pulumi.get(self, "sender_application_id")

    @sender_application_id.setter
    def sender_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_id", value)

    @property
    @pulumi.getter(name="senderApplicationQualifier")
    def sender_application_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application qualifier.
        """
        return pulumi.get(self, "sender_application_qualifier")

    @sender_application_qualifier.setter
    def sender_application_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_qualifier", value)


@pulumi.input_type
class EdifactValidationOverrideArgs:
    def __init__(__self__, *,
                 allow_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 enforce_character_set: Optional[pulumi.Input[bool]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 trailing_separator_policy: Optional[pulumi.Input['TrailingSeparatorPolicy']] = None,
                 trim_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 validate_edi_types: Optional[pulumi.Input[bool]] = None,
                 validate_xsd_types: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] allow_leading_and_trailing_spaces_and_zeroes: The value indicating whether to allow leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] enforce_character_set: The value indicating whether to validate character Set.
        :param pulumi.Input[str] message_id: The message id on which the validation settings has to be applied.
        :param pulumi.Input['TrailingSeparatorPolicy'] trailing_separator_policy: The trailing separator policy.
        :param pulumi.Input[bool] trim_leading_and_trailing_spaces_and_zeroes: The value indicating whether to trim leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] validate_edi_types: The value indicating whether to validate EDI types.
        :param pulumi.Input[bool] validate_xsd_types: The value indicating whether to validate XSD types.
        """
        if allow_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "allow_leading_and_trailing_spaces_and_zeroes", allow_leading_and_trailing_spaces_and_zeroes)
        if enforce_character_set is not None:
            pulumi.set(__self__, "enforce_character_set", enforce_character_set)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if trailing_separator_policy is not None:
            pulumi.set(__self__, "trailing_separator_policy", trailing_separator_policy)
        if trim_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "trim_leading_and_trailing_spaces_and_zeroes", trim_leading_and_trailing_spaces_and_zeroes)
        if validate_edi_types is not None:
            pulumi.set(__self__, "validate_edi_types", validate_edi_types)
        if validate_xsd_types is not None:
            pulumi.set(__self__, "validate_xsd_types", validate_xsd_types)

    @property
    @pulumi.getter(name="allowLeadingAndTrailingSpacesAndZeroes")
    def allow_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to allow leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "allow_leading_and_trailing_spaces_and_zeroes")

    @allow_leading_and_trailing_spaces_and_zeroes.setter
    def allow_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="enforceCharacterSet")
    def enforce_character_set(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate character Set.
        """
        return pulumi.get(self, "enforce_character_set")

    @enforce_character_set.setter
    def enforce_character_set(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enforce_character_set", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id on which the validation settings has to be applied.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="trailingSeparatorPolicy")
    def trailing_separator_policy(self) -> Optional[pulumi.Input['TrailingSeparatorPolicy']]:
        """
        The trailing separator policy.
        """
        return pulumi.get(self, "trailing_separator_policy")

    @trailing_separator_policy.setter
    def trailing_separator_policy(self, value: Optional[pulumi.Input['TrailingSeparatorPolicy']]):
        pulumi.set(self, "trailing_separator_policy", value)

    @property
    @pulumi.getter(name="trimLeadingAndTrailingSpacesAndZeroes")
    def trim_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to trim leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "trim_leading_and_trailing_spaces_and_zeroes")

    @trim_leading_and_trailing_spaces_and_zeroes.setter
    def trim_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "trim_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="validateEDITypes")
    def validate_edi_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate EDI types.
        """
        return pulumi.get(self, "validate_edi_types")

    @validate_edi_types.setter
    def validate_edi_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_edi_types", value)

    @property
    @pulumi.getter(name="validateXSDTypes")
    def validate_xsd_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate XSD types.
        """
        return pulumi.get(self, "validate_xsd_types")

    @validate_xsd_types.setter
    def validate_xsd_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_xsd_types", value)


@pulumi.input_type
class EdifactValidationSettingsArgs:
    def __init__(__self__, *,
                 allow_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_group_control_number: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_interchange_control_number: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_transaction_set_control_number: Optional[pulumi.Input[bool]] = None,
                 interchange_control_number_validity_days: Optional[pulumi.Input[int]] = None,
                 trailing_separator_policy: Optional[pulumi.Input['TrailingSeparatorPolicy']] = None,
                 trim_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 validate_character_set: Optional[pulumi.Input[bool]] = None,
                 validate_edi_types: Optional[pulumi.Input[bool]] = None,
                 validate_xsd_types: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] allow_leading_and_trailing_spaces_and_zeroes: The value indicating whether to allow leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] check_duplicate_group_control_number: The value indicating whether to check for duplicate group control number.
        :param pulumi.Input[bool] check_duplicate_interchange_control_number: The value indicating whether to check for duplicate interchange control number.
        :param pulumi.Input[bool] check_duplicate_transaction_set_control_number: The value indicating whether to check for duplicate transaction set control number.
        :param pulumi.Input[int] interchange_control_number_validity_days: The validity period of interchange control number.
        :param pulumi.Input['TrailingSeparatorPolicy'] trailing_separator_policy: The trailing separator policy.
        :param pulumi.Input[bool] trim_leading_and_trailing_spaces_and_zeroes: The value indicating whether to trim leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] validate_character_set: The value indicating whether to validate character set in the message.
        :param pulumi.Input[bool] validate_edi_types: The value indicating whether to Whether to validate EDI types.
        :param pulumi.Input[bool] validate_xsd_types: The value indicating whether to Whether to validate XSD types.
        """
        if allow_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "allow_leading_and_trailing_spaces_and_zeroes", allow_leading_and_trailing_spaces_and_zeroes)
        if check_duplicate_group_control_number is not None:
            pulumi.set(__self__, "check_duplicate_group_control_number", check_duplicate_group_control_number)
        if check_duplicate_interchange_control_number is not None:
            pulumi.set(__self__, "check_duplicate_interchange_control_number", check_duplicate_interchange_control_number)
        if check_duplicate_transaction_set_control_number is not None:
            pulumi.set(__self__, "check_duplicate_transaction_set_control_number", check_duplicate_transaction_set_control_number)
        if interchange_control_number_validity_days is not None:
            pulumi.set(__self__, "interchange_control_number_validity_days", interchange_control_number_validity_days)
        if trailing_separator_policy is not None:
            pulumi.set(__self__, "trailing_separator_policy", trailing_separator_policy)
        if trim_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "trim_leading_and_trailing_spaces_and_zeroes", trim_leading_and_trailing_spaces_and_zeroes)
        if validate_character_set is not None:
            pulumi.set(__self__, "validate_character_set", validate_character_set)
        if validate_edi_types is not None:
            pulumi.set(__self__, "validate_edi_types", validate_edi_types)
        if validate_xsd_types is not None:
            pulumi.set(__self__, "validate_xsd_types", validate_xsd_types)

    @property
    @pulumi.getter(name="allowLeadingAndTrailingSpacesAndZeroes")
    def allow_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to allow leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "allow_leading_and_trailing_spaces_and_zeroes")

    @allow_leading_and_trailing_spaces_and_zeroes.setter
    def allow_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="checkDuplicateGroupControlNumber")
    def check_duplicate_group_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate group control number.
        """
        return pulumi.get(self, "check_duplicate_group_control_number")

    @check_duplicate_group_control_number.setter
    def check_duplicate_group_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_group_control_number", value)

    @property
    @pulumi.getter(name="checkDuplicateInterchangeControlNumber")
    def check_duplicate_interchange_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate interchange control number.
        """
        return pulumi.get(self, "check_duplicate_interchange_control_number")

    @check_duplicate_interchange_control_number.setter
    def check_duplicate_interchange_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_interchange_control_number", value)

    @property
    @pulumi.getter(name="checkDuplicateTransactionSetControlNumber")
    def check_duplicate_transaction_set_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate transaction set control number.
        """
        return pulumi.get(self, "check_duplicate_transaction_set_control_number")

    @check_duplicate_transaction_set_control_number.setter
    def check_duplicate_transaction_set_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_transaction_set_control_number", value)

    @property
    @pulumi.getter(name="interchangeControlNumberValidityDays")
    def interchange_control_number_validity_days(self) -> Optional[pulumi.Input[int]]:
        """
        The validity period of interchange control number.
        """
        return pulumi.get(self, "interchange_control_number_validity_days")

    @interchange_control_number_validity_days.setter
    def interchange_control_number_validity_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interchange_control_number_validity_days", value)

    @property
    @pulumi.getter(name="trailingSeparatorPolicy")
    def trailing_separator_policy(self) -> Optional[pulumi.Input['TrailingSeparatorPolicy']]:
        """
        The trailing separator policy.
        """
        return pulumi.get(self, "trailing_separator_policy")

    @trailing_separator_policy.setter
    def trailing_separator_policy(self, value: Optional[pulumi.Input['TrailingSeparatorPolicy']]):
        pulumi.set(self, "trailing_separator_policy", value)

    @property
    @pulumi.getter(name="trimLeadingAndTrailingSpacesAndZeroes")
    def trim_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to trim leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "trim_leading_and_trailing_spaces_and_zeroes")

    @trim_leading_and_trailing_spaces_and_zeroes.setter
    def trim_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "trim_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="validateCharacterSet")
    def validate_character_set(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate character set in the message.
        """
        return pulumi.get(self, "validate_character_set")

    @validate_character_set.setter
    def validate_character_set(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_character_set", value)

    @property
    @pulumi.getter(name="validateEDITypes")
    def validate_edi_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to Whether to validate EDI types.
        """
        return pulumi.get(self, "validate_edi_types")

    @validate_edi_types.setter
    def validate_edi_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_edi_types", value)

    @property
    @pulumi.getter(name="validateXSDTypes")
    def validate_xsd_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to Whether to validate XSD types.
        """
        return pulumi.get(self, "validate_xsd_types")

    @validate_xsd_types.setter
    def validate_xsd_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_xsd_types", value)


@pulumi.input_type
class IntegrationAccountSkuArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input['SkuName']] = None):
        """
        :param pulumi.Input['SkuName'] name: The sku name.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input['SkuName']]:
        """
        The sku name.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input['SkuName']]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class KeyVaultKeyReferenceKeyVaultArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None):
        """
        The key vault reference.
        :param pulumi.Input[str] id: The resource id.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        """
        The resource id.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)


@pulumi.input_type
class KeyVaultKeyReferenceArgs:
    def __init__(__self__, *,
                 key_name: Optional[pulumi.Input[str]] = None,
                 key_vault: Optional[pulumi.Input['KeyVaultKeyReferenceKeyVaultArgs']] = None,
                 key_version: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_name: The private key name in key vault.
        :param pulumi.Input['KeyVaultKeyReferenceKeyVaultArgs'] key_vault: The key vault reference.
        :param pulumi.Input[str] key_version: The private key version in key vault.
        """
        if key_name is not None:
            pulumi.set(__self__, "key_name", key_name)
        if key_vault is not None:
            pulumi.set(__self__, "key_vault", key_vault)
        if key_version is not None:
            pulumi.set(__self__, "key_version", key_version)

    @property
    @pulumi.getter(name="keyName")
    def key_name(self) -> Optional[pulumi.Input[str]]:
        """
        The private key name in key vault.
        """
        return pulumi.get(self, "key_name")

    @key_name.setter
    def key_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_name", value)

    @property
    @pulumi.getter(name="keyVault")
    def key_vault(self) -> Optional[pulumi.Input['KeyVaultKeyReferenceKeyVaultArgs']]:
        """
        The key vault reference.
        """
        return pulumi.get(self, "key_vault")

    @key_vault.setter
    def key_vault(self, value: Optional[pulumi.Input['KeyVaultKeyReferenceKeyVaultArgs']]):
        pulumi.set(self, "key_vault", value)

    @property
    @pulumi.getter(name="keyVersion")
    def key_version(self) -> Optional[pulumi.Input[str]]:
        """
        The private key version in key vault.
        """
        return pulumi.get(self, "key_version")

    @key_version.setter
    def key_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_version", value)


@pulumi.input_type
class PartnerContentArgs:
    def __init__(__self__, *,
                 b2b: Optional[pulumi.Input['B2BPartnerContentArgs']] = None):
        """
        :param pulumi.Input['B2BPartnerContentArgs'] b2b: The B2B partner content.
        """
        if b2b is not None:
            pulumi.set(__self__, "b2b", b2b)

    @property
    @pulumi.getter
    def b2b(self) -> Optional[pulumi.Input['B2BPartnerContentArgs']]:
        """
        The B2B partner content.
        """
        return pulumi.get(self, "b2b")

    @b2b.setter
    def b2b(self, value: Optional[pulumi.Input['B2BPartnerContentArgs']]):
        pulumi.set(self, "b2b", value)


@pulumi.input_type
class X12AcknowledgementSettingsArgs:
    def __init__(__self__, *,
                 acknowledgement_control_number_lower_bound: Optional[pulumi.Input[int]] = None,
                 acknowledgement_control_number_prefix: Optional[pulumi.Input[str]] = None,
                 acknowledgement_control_number_suffix: Optional[pulumi.Input[str]] = None,
                 acknowledgement_control_number_upper_bound: Optional[pulumi.Input[int]] = None,
                 batch_functional_acknowledgements: Optional[pulumi.Input[bool]] = None,
                 batch_implementation_acknowledgements: Optional[pulumi.Input[bool]] = None,
                 batch_technical_acknowledgements: Optional[pulumi.Input[bool]] = None,
                 functional_acknowledgement_version: Optional[pulumi.Input[str]] = None,
                 implementation_acknowledgement_version: Optional[pulumi.Input[str]] = None,
                 need_functional_acknowledgement: Optional[pulumi.Input[bool]] = None,
                 need_implementation_acknowledgement: Optional[pulumi.Input[bool]] = None,
                 need_loop_for_valid_messages: Optional[pulumi.Input[bool]] = None,
                 need_technical_acknowledgement: Optional[pulumi.Input[bool]] = None,
                 rollover_acknowledgement_control_number: Optional[pulumi.Input[bool]] = None,
                 send_synchronous_acknowledgement: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[int] acknowledgement_control_number_lower_bound: The acknowledgement control number lower bound.
        :param pulumi.Input[str] acknowledgement_control_number_prefix: The acknowledgement control number prefix.
        :param pulumi.Input[str] acknowledgement_control_number_suffix: The acknowledgement control number suffix.
        :param pulumi.Input[int] acknowledgement_control_number_upper_bound: The acknowledgement control number upper bound.
        :param pulumi.Input[bool] batch_functional_acknowledgements: The value indicating whether to batch functional acknowledgements.
        :param pulumi.Input[bool] batch_implementation_acknowledgements: The value indicating whether to batch implementation acknowledgements.
        :param pulumi.Input[bool] batch_technical_acknowledgements: The value indicating whether to batch the technical acknowledgements.
        :param pulumi.Input[str] functional_acknowledgement_version: The functional acknowledgement version.
        :param pulumi.Input[str] implementation_acknowledgement_version: The implementation acknowledgement version.
        :param pulumi.Input[bool] need_functional_acknowledgement: The value indicating whether functional acknowledgement is needed.
        :param pulumi.Input[bool] need_implementation_acknowledgement: The value indicating whether implementation acknowledgement is needed.
        :param pulumi.Input[bool] need_loop_for_valid_messages: The value indicating whether a loop is needed for valid messages.
        :param pulumi.Input[bool] need_technical_acknowledgement: The value indicating whether technical acknowledgement is needed.
        :param pulumi.Input[bool] rollover_acknowledgement_control_number: The value indicating whether to rollover acknowledgement control number.
        :param pulumi.Input[bool] send_synchronous_acknowledgement: The value indicating whether to send synchronous acknowledgement.
        """
        if acknowledgement_control_number_lower_bound is not None:
            pulumi.set(__self__, "acknowledgement_control_number_lower_bound", acknowledgement_control_number_lower_bound)
        if acknowledgement_control_number_prefix is not None:
            pulumi.set(__self__, "acknowledgement_control_number_prefix", acknowledgement_control_number_prefix)
        if acknowledgement_control_number_suffix is not None:
            pulumi.set(__self__, "acknowledgement_control_number_suffix", acknowledgement_control_number_suffix)
        if acknowledgement_control_number_upper_bound is not None:
            pulumi.set(__self__, "acknowledgement_control_number_upper_bound", acknowledgement_control_number_upper_bound)
        if batch_functional_acknowledgements is not None:
            pulumi.set(__self__, "batch_functional_acknowledgements", batch_functional_acknowledgements)
        if batch_implementation_acknowledgements is not None:
            pulumi.set(__self__, "batch_implementation_acknowledgements", batch_implementation_acknowledgements)
        if batch_technical_acknowledgements is not None:
            pulumi.set(__self__, "batch_technical_acknowledgements", batch_technical_acknowledgements)
        if functional_acknowledgement_version is not None:
            pulumi.set(__self__, "functional_acknowledgement_version", functional_acknowledgement_version)
        if implementation_acknowledgement_version is not None:
            pulumi.set(__self__, "implementation_acknowledgement_version", implementation_acknowledgement_version)
        if need_functional_acknowledgement is not None:
            pulumi.set(__self__, "need_functional_acknowledgement", need_functional_acknowledgement)
        if need_implementation_acknowledgement is not None:
            pulumi.set(__self__, "need_implementation_acknowledgement", need_implementation_acknowledgement)
        if need_loop_for_valid_messages is not None:
            pulumi.set(__self__, "need_loop_for_valid_messages", need_loop_for_valid_messages)
        if need_technical_acknowledgement is not None:
            pulumi.set(__self__, "need_technical_acknowledgement", need_technical_acknowledgement)
        if rollover_acknowledgement_control_number is not None:
            pulumi.set(__self__, "rollover_acknowledgement_control_number", rollover_acknowledgement_control_number)
        if send_synchronous_acknowledgement is not None:
            pulumi.set(__self__, "send_synchronous_acknowledgement", send_synchronous_acknowledgement)

    @property
    @pulumi.getter(name="acknowledgementControlNumberLowerBound")
    def acknowledgement_control_number_lower_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The acknowledgement control number lower bound.
        """
        return pulumi.get(self, "acknowledgement_control_number_lower_bound")

    @acknowledgement_control_number_lower_bound.setter
    def acknowledgement_control_number_lower_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "acknowledgement_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="acknowledgementControlNumberPrefix")
    def acknowledgement_control_number_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The acknowledgement control number prefix.
        """
        return pulumi.get(self, "acknowledgement_control_number_prefix")

    @acknowledgement_control_number_prefix.setter
    def acknowledgement_control_number_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "acknowledgement_control_number_prefix", value)

    @property
    @pulumi.getter(name="acknowledgementControlNumberSuffix")
    def acknowledgement_control_number_suffix(self) -> Optional[pulumi.Input[str]]:
        """
        The acknowledgement control number suffix.
        """
        return pulumi.get(self, "acknowledgement_control_number_suffix")

    @acknowledgement_control_number_suffix.setter
    def acknowledgement_control_number_suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "acknowledgement_control_number_suffix", value)

    @property
    @pulumi.getter(name="acknowledgementControlNumberUpperBound")
    def acknowledgement_control_number_upper_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The acknowledgement control number upper bound.
        """
        return pulumi.get(self, "acknowledgement_control_number_upper_bound")

    @acknowledgement_control_number_upper_bound.setter
    def acknowledgement_control_number_upper_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "acknowledgement_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="batchFunctionalAcknowledgements")
    def batch_functional_acknowledgements(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to batch functional acknowledgements.
        """
        return pulumi.get(self, "batch_functional_acknowledgements")

    @batch_functional_acknowledgements.setter
    def batch_functional_acknowledgements(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_functional_acknowledgements", value)

    @property
    @pulumi.getter(name="batchImplementationAcknowledgements")
    def batch_implementation_acknowledgements(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to batch implementation acknowledgements.
        """
        return pulumi.get(self, "batch_implementation_acknowledgements")

    @batch_implementation_acknowledgements.setter
    def batch_implementation_acknowledgements(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_implementation_acknowledgements", value)

    @property
    @pulumi.getter(name="batchTechnicalAcknowledgements")
    def batch_technical_acknowledgements(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to batch the technical acknowledgements.
        """
        return pulumi.get(self, "batch_technical_acknowledgements")

    @batch_technical_acknowledgements.setter
    def batch_technical_acknowledgements(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_technical_acknowledgements", value)

    @property
    @pulumi.getter(name="functionalAcknowledgementVersion")
    def functional_acknowledgement_version(self) -> Optional[pulumi.Input[str]]:
        """
        The functional acknowledgement version.
        """
        return pulumi.get(self, "functional_acknowledgement_version")

    @functional_acknowledgement_version.setter
    def functional_acknowledgement_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "functional_acknowledgement_version", value)

    @property
    @pulumi.getter(name="implementationAcknowledgementVersion")
    def implementation_acknowledgement_version(self) -> Optional[pulumi.Input[str]]:
        """
        The implementation acknowledgement version.
        """
        return pulumi.get(self, "implementation_acknowledgement_version")

    @implementation_acknowledgement_version.setter
    def implementation_acknowledgement_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "implementation_acknowledgement_version", value)

    @property
    @pulumi.getter(name="needFunctionalAcknowledgement")
    def need_functional_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether functional acknowledgement is needed.
        """
        return pulumi.get(self, "need_functional_acknowledgement")

    @need_functional_acknowledgement.setter
    def need_functional_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_functional_acknowledgement", value)

    @property
    @pulumi.getter(name="needImplementationAcknowledgement")
    def need_implementation_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether implementation acknowledgement is needed.
        """
        return pulumi.get(self, "need_implementation_acknowledgement")

    @need_implementation_acknowledgement.setter
    def need_implementation_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_implementation_acknowledgement", value)

    @property
    @pulumi.getter(name="needLoopForValidMessages")
    def need_loop_for_valid_messages(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether a loop is needed for valid messages.
        """
        return pulumi.get(self, "need_loop_for_valid_messages")

    @need_loop_for_valid_messages.setter
    def need_loop_for_valid_messages(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_loop_for_valid_messages", value)

    @property
    @pulumi.getter(name="needTechnicalAcknowledgement")
    def need_technical_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether technical acknowledgement is needed.
        """
        return pulumi.get(self, "need_technical_acknowledgement")

    @need_technical_acknowledgement.setter
    def need_technical_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "need_technical_acknowledgement", value)

    @property
    @pulumi.getter(name="rolloverAcknowledgementControlNumber")
    def rollover_acknowledgement_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover acknowledgement control number.
        """
        return pulumi.get(self, "rollover_acknowledgement_control_number")

    @rollover_acknowledgement_control_number.setter
    def rollover_acknowledgement_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_acknowledgement_control_number", value)

    @property
    @pulumi.getter(name="sendSynchronousAcknowledgement")
    def send_synchronous_acknowledgement(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to send synchronous acknowledgement.
        """
        return pulumi.get(self, "send_synchronous_acknowledgement")

    @send_synchronous_acknowledgement.setter
    def send_synchronous_acknowledgement(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "send_synchronous_acknowledgement", value)


@pulumi.input_type
class X12AgreementContentArgs:
    def __init__(__self__, *,
                 receive_agreement: Optional[pulumi.Input['X12OneWayAgreementArgs']] = None,
                 send_agreement: Optional[pulumi.Input['X12OneWayAgreementArgs']] = None):
        """
        :param pulumi.Input['X12OneWayAgreementArgs'] receive_agreement: The X12 one-way receive agreement.
        :param pulumi.Input['X12OneWayAgreementArgs'] send_agreement: The X12 one-way send agreement.
        """
        if receive_agreement is not None:
            pulumi.set(__self__, "receive_agreement", receive_agreement)
        if send_agreement is not None:
            pulumi.set(__self__, "send_agreement", send_agreement)

    @property
    @pulumi.getter(name="receiveAgreement")
    def receive_agreement(self) -> Optional[pulumi.Input['X12OneWayAgreementArgs']]:
        """
        The X12 one-way receive agreement.
        """
        return pulumi.get(self, "receive_agreement")

    @receive_agreement.setter
    def receive_agreement(self, value: Optional[pulumi.Input['X12OneWayAgreementArgs']]):
        pulumi.set(self, "receive_agreement", value)

    @property
    @pulumi.getter(name="sendAgreement")
    def send_agreement(self) -> Optional[pulumi.Input['X12OneWayAgreementArgs']]:
        """
        The X12 one-way send agreement.
        """
        return pulumi.get(self, "send_agreement")

    @send_agreement.setter
    def send_agreement(self, value: Optional[pulumi.Input['X12OneWayAgreementArgs']]):
        pulumi.set(self, "send_agreement", value)


@pulumi.input_type
class X12DelimiterOverridesArgs:
    def __init__(__self__, *,
                 component_separator: Optional[pulumi.Input[int]] = None,
                 data_element_separator: Optional[pulumi.Input[int]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 protocol_version: Optional[pulumi.Input[str]] = None,
                 replace_character: Optional[pulumi.Input[int]] = None,
                 replace_separators_in_payload: Optional[pulumi.Input[bool]] = None,
                 segment_terminator: Optional[pulumi.Input[int]] = None,
                 segment_terminator_suffix: Optional[pulumi.Input['SegmentTerminatorSuffix']] = None,
                 target_namespace: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] component_separator: The component separator.
        :param pulumi.Input[int] data_element_separator: The data element separator.
        :param pulumi.Input[str] message_id: The message id.
        :param pulumi.Input[str] protocol_version: The protocol version.
        :param pulumi.Input[int] replace_character: The replacement character.
        :param pulumi.Input[bool] replace_separators_in_payload: The value indicating whether to replace separators in payload.
        :param pulumi.Input[int] segment_terminator: The segment terminator.
        :param pulumi.Input['SegmentTerminatorSuffix'] segment_terminator_suffix: The segment terminator suffix.
        :param pulumi.Input[str] target_namespace: The target namespace on which this delimiter settings has to be applied.
        """
        if component_separator is not None:
            pulumi.set(__self__, "component_separator", component_separator)
        if data_element_separator is not None:
            pulumi.set(__self__, "data_element_separator", data_element_separator)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if protocol_version is not None:
            pulumi.set(__self__, "protocol_version", protocol_version)
        if replace_character is not None:
            pulumi.set(__self__, "replace_character", replace_character)
        if replace_separators_in_payload is not None:
            pulumi.set(__self__, "replace_separators_in_payload", replace_separators_in_payload)
        if segment_terminator is not None:
            pulumi.set(__self__, "segment_terminator", segment_terminator)
        if segment_terminator_suffix is not None:
            pulumi.set(__self__, "segment_terminator_suffix", segment_terminator_suffix)
        if target_namespace is not None:
            pulumi.set(__self__, "target_namespace", target_namespace)

    @property
    @pulumi.getter(name="componentSeparator")
    def component_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The component separator.
        """
        return pulumi.get(self, "component_separator")

    @component_separator.setter
    def component_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "component_separator", value)

    @property
    @pulumi.getter(name="dataElementSeparator")
    def data_element_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The data element separator.
        """
        return pulumi.get(self, "data_element_separator")

    @data_element_separator.setter
    def data_element_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "data_element_separator", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="protocolVersion")
    def protocol_version(self) -> Optional[pulumi.Input[str]]:
        """
        The protocol version.
        """
        return pulumi.get(self, "protocol_version")

    @protocol_version.setter
    def protocol_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol_version", value)

    @property
    @pulumi.getter(name="replaceCharacter")
    def replace_character(self) -> Optional[pulumi.Input[int]]:
        """
        The replacement character.
        """
        return pulumi.get(self, "replace_character")

    @replace_character.setter
    def replace_character(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "replace_character", value)

    @property
    @pulumi.getter(name="replaceSeparatorsInPayload")
    def replace_separators_in_payload(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to replace separators in payload.
        """
        return pulumi.get(self, "replace_separators_in_payload")

    @replace_separators_in_payload.setter
    def replace_separators_in_payload(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace_separators_in_payload", value)

    @property
    @pulumi.getter(name="segmentTerminator")
    def segment_terminator(self) -> Optional[pulumi.Input[int]]:
        """
        The segment terminator.
        """
        return pulumi.get(self, "segment_terminator")

    @segment_terminator.setter
    def segment_terminator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "segment_terminator", value)

    @property
    @pulumi.getter(name="segmentTerminatorSuffix")
    def segment_terminator_suffix(self) -> Optional[pulumi.Input['SegmentTerminatorSuffix']]:
        """
        The segment terminator suffix.
        """
        return pulumi.get(self, "segment_terminator_suffix")

    @segment_terminator_suffix.setter
    def segment_terminator_suffix(self, value: Optional[pulumi.Input['SegmentTerminatorSuffix']]):
        pulumi.set(self, "segment_terminator_suffix", value)

    @property
    @pulumi.getter(name="targetNamespace")
    def target_namespace(self) -> Optional[pulumi.Input[str]]:
        """
        The target namespace on which this delimiter settings has to be applied.
        """
        return pulumi.get(self, "target_namespace")

    @target_namespace.setter
    def target_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_namespace", value)


@pulumi.input_type
class X12EnvelopeOverrideArgs:
    def __init__(__self__, *,
                 date_format: Optional[pulumi.Input['X12DateFormat']] = None,
                 functional_identifier_code: Optional[pulumi.Input[str]] = None,
                 header_version: Optional[pulumi.Input[str]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 protocol_version: Optional[pulumi.Input[str]] = None,
                 receiver_application_id: Optional[pulumi.Input[str]] = None,
                 responsible_agency_code: Optional[pulumi.Input[int]] = None,
                 sender_application_id: Optional[pulumi.Input[str]] = None,
                 target_namespace: Optional[pulumi.Input[str]] = None,
                 time_format: Optional[pulumi.Input['X12TimeFormat']] = None):
        """
        :param pulumi.Input['X12DateFormat'] date_format: The date format.
        :param pulumi.Input[str] functional_identifier_code: The functional identifier code.
        :param pulumi.Input[str] header_version: The header version.
        :param pulumi.Input[str] message_id: The message id on which this envelope settings has to be applied.
        :param pulumi.Input[str] protocol_version: The protocol version on which this envelope settings has to be applied.
        :param pulumi.Input[str] receiver_application_id: The receiver application id.
        :param pulumi.Input[int] responsible_agency_code: The responsible agency code.
        :param pulumi.Input[str] sender_application_id: The sender application id.
        :param pulumi.Input[str] target_namespace: The target namespace on which this envelope settings has to be applied.
        :param pulumi.Input['X12TimeFormat'] time_format: The time format.
        """
        if date_format is not None:
            pulumi.set(__self__, "date_format", date_format)
        if functional_identifier_code is not None:
            pulumi.set(__self__, "functional_identifier_code", functional_identifier_code)
        if header_version is not None:
            pulumi.set(__self__, "header_version", header_version)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if protocol_version is not None:
            pulumi.set(__self__, "protocol_version", protocol_version)
        if receiver_application_id is not None:
            pulumi.set(__self__, "receiver_application_id", receiver_application_id)
        if responsible_agency_code is not None:
            pulumi.set(__self__, "responsible_agency_code", responsible_agency_code)
        if sender_application_id is not None:
            pulumi.set(__self__, "sender_application_id", sender_application_id)
        if target_namespace is not None:
            pulumi.set(__self__, "target_namespace", target_namespace)
        if time_format is not None:
            pulumi.set(__self__, "time_format", time_format)

    @property
    @pulumi.getter(name="dateFormat")
    def date_format(self) -> Optional[pulumi.Input['X12DateFormat']]:
        """
        The date format.
        """
        return pulumi.get(self, "date_format")

    @date_format.setter
    def date_format(self, value: Optional[pulumi.Input['X12DateFormat']]):
        pulumi.set(self, "date_format", value)

    @property
    @pulumi.getter(name="functionalIdentifierCode")
    def functional_identifier_code(self) -> Optional[pulumi.Input[str]]:
        """
        The functional identifier code.
        """
        return pulumi.get(self, "functional_identifier_code")

    @functional_identifier_code.setter
    def functional_identifier_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "functional_identifier_code", value)

    @property
    @pulumi.getter(name="headerVersion")
    def header_version(self) -> Optional[pulumi.Input[str]]:
        """
        The header version.
        """
        return pulumi.get(self, "header_version")

    @header_version.setter
    def header_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header_version", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="protocolVersion")
    def protocol_version(self) -> Optional[pulumi.Input[str]]:
        """
        The protocol version on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "protocol_version")

    @protocol_version.setter
    def protocol_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol_version", value)

    @property
    @pulumi.getter(name="receiverApplicationId")
    def receiver_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver application id.
        """
        return pulumi.get(self, "receiver_application_id")

    @receiver_application_id.setter
    def receiver_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_application_id", value)

    @property
    @pulumi.getter(name="responsibleAgencyCode")
    def responsible_agency_code(self) -> Optional[pulumi.Input[int]]:
        """
        The responsible agency code.
        """
        return pulumi.get(self, "responsible_agency_code")

    @responsible_agency_code.setter
    def responsible_agency_code(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "responsible_agency_code", value)

    @property
    @pulumi.getter(name="senderApplicationId")
    def sender_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application id.
        """
        return pulumi.get(self, "sender_application_id")

    @sender_application_id.setter
    def sender_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_id", value)

    @property
    @pulumi.getter(name="targetNamespace")
    def target_namespace(self) -> Optional[pulumi.Input[str]]:
        """
        The target namespace on which this envelope settings has to be applied.
        """
        return pulumi.get(self, "target_namespace")

    @target_namespace.setter
    def target_namespace(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_namespace", value)

    @property
    @pulumi.getter(name="timeFormat")
    def time_format(self) -> Optional[pulumi.Input['X12TimeFormat']]:
        """
        The time format.
        """
        return pulumi.get(self, "time_format")

    @time_format.setter
    def time_format(self, value: Optional[pulumi.Input['X12TimeFormat']]):
        pulumi.set(self, "time_format", value)


@pulumi.input_type
class X12EnvelopeSettingsArgs:
    def __init__(__self__, *,
                 control_standards_id: Optional[pulumi.Input[int]] = None,
                 control_version_number: Optional[pulumi.Input[str]] = None,
                 enable_default_group_headers: Optional[pulumi.Input[bool]] = None,
                 functional_group_id: Optional[pulumi.Input[str]] = None,
                 group_control_number_lower_bound: Optional[pulumi.Input[int]] = None,
                 group_control_number_upper_bound: Optional[pulumi.Input[int]] = None,
                 group_header_agency_code: Optional[pulumi.Input[str]] = None,
                 group_header_date_format: Optional[pulumi.Input['X12DateFormat']] = None,
                 group_header_time_format: Optional[pulumi.Input['X12TimeFormat']] = None,
                 group_header_version: Optional[pulumi.Input[str]] = None,
                 interchange_control_number_lower_bound: Optional[pulumi.Input[int]] = None,
                 interchange_control_number_upper_bound: Optional[pulumi.Input[int]] = None,
                 overwrite_existing_transaction_set_control_number: Optional[pulumi.Input[bool]] = None,
                 receiver_application_id: Optional[pulumi.Input[str]] = None,
                 rollover_group_control_number: Optional[pulumi.Input[bool]] = None,
                 rollover_interchange_control_number: Optional[pulumi.Input[bool]] = None,
                 rollover_transaction_set_control_number: Optional[pulumi.Input[bool]] = None,
                 sender_application_id: Optional[pulumi.Input[str]] = None,
                 transaction_set_control_number_lower_bound: Optional[pulumi.Input[int]] = None,
                 transaction_set_control_number_prefix: Optional[pulumi.Input[str]] = None,
                 transaction_set_control_number_suffix: Optional[pulumi.Input[str]] = None,
                 transaction_set_control_number_upper_bound: Optional[pulumi.Input[int]] = None,
                 usage_indicator: Optional[pulumi.Input['UsageIndicator']] = None,
                 use_control_standards_id_as_repetition_character: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[int] control_standards_id: The controls standards id.
        :param pulumi.Input[str] control_version_number: The control version number.
        :param pulumi.Input[bool] enable_default_group_headers: The value indicating whether to enable default group headers.
        :param pulumi.Input[str] functional_group_id: The functional group id.
        :param pulumi.Input[int] group_control_number_lower_bound: The group control number lower bound.
        :param pulumi.Input[int] group_control_number_upper_bound: The group control number upper bound.
        :param pulumi.Input[str] group_header_agency_code: The group header agency code.
        :param pulumi.Input['X12DateFormat'] group_header_date_format: The group header date format.
        :param pulumi.Input['X12TimeFormat'] group_header_time_format: The group header time format.
        :param pulumi.Input[str] group_header_version: The group header version.
        :param pulumi.Input[int] interchange_control_number_lower_bound: The interchange  control number lower bound.
        :param pulumi.Input[int] interchange_control_number_upper_bound: The interchange  control number upper bound.
        :param pulumi.Input[bool] overwrite_existing_transaction_set_control_number: The value indicating whether to overwrite existing transaction set control number.
        :param pulumi.Input[str] receiver_application_id: The receiver application id.
        :param pulumi.Input[bool] rollover_group_control_number: The value indicating whether to rollover group control number.
        :param pulumi.Input[bool] rollover_interchange_control_number: The value indicating whether to rollover interchange control number.
        :param pulumi.Input[bool] rollover_transaction_set_control_number: The value indicating whether to rollover transaction set control number.
        :param pulumi.Input[str] sender_application_id: The sender application id.
        :param pulumi.Input[int] transaction_set_control_number_lower_bound: The transaction set control number lower bound.
        :param pulumi.Input[str] transaction_set_control_number_prefix: The transaction set control number prefix.
        :param pulumi.Input[str] transaction_set_control_number_suffix: The transaction set control number suffix.
        :param pulumi.Input[int] transaction_set_control_number_upper_bound: The transaction set control number upper bound.
        :param pulumi.Input['UsageIndicator'] usage_indicator: The usage indicator.
        :param pulumi.Input[bool] use_control_standards_id_as_repetition_character: The value indicating whether to use control standards id as repetition character.
        """
        if control_standards_id is not None:
            pulumi.set(__self__, "control_standards_id", control_standards_id)
        if control_version_number is not None:
            pulumi.set(__self__, "control_version_number", control_version_number)
        if enable_default_group_headers is not None:
            pulumi.set(__self__, "enable_default_group_headers", enable_default_group_headers)
        if functional_group_id is not None:
            pulumi.set(__self__, "functional_group_id", functional_group_id)
        if group_control_number_lower_bound is not None:
            pulumi.set(__self__, "group_control_number_lower_bound", group_control_number_lower_bound)
        if group_control_number_upper_bound is not None:
            pulumi.set(__self__, "group_control_number_upper_bound", group_control_number_upper_bound)
        if group_header_agency_code is not None:
            pulumi.set(__self__, "group_header_agency_code", group_header_agency_code)
        if group_header_date_format is not None:
            pulumi.set(__self__, "group_header_date_format", group_header_date_format)
        if group_header_time_format is not None:
            pulumi.set(__self__, "group_header_time_format", group_header_time_format)
        if group_header_version is not None:
            pulumi.set(__self__, "group_header_version", group_header_version)
        if interchange_control_number_lower_bound is not None:
            pulumi.set(__self__, "interchange_control_number_lower_bound", interchange_control_number_lower_bound)
        if interchange_control_number_upper_bound is not None:
            pulumi.set(__self__, "interchange_control_number_upper_bound", interchange_control_number_upper_bound)
        if overwrite_existing_transaction_set_control_number is not None:
            pulumi.set(__self__, "overwrite_existing_transaction_set_control_number", overwrite_existing_transaction_set_control_number)
        if receiver_application_id is not None:
            pulumi.set(__self__, "receiver_application_id", receiver_application_id)
        if rollover_group_control_number is not None:
            pulumi.set(__self__, "rollover_group_control_number", rollover_group_control_number)
        if rollover_interchange_control_number is not None:
            pulumi.set(__self__, "rollover_interchange_control_number", rollover_interchange_control_number)
        if rollover_transaction_set_control_number is not None:
            pulumi.set(__self__, "rollover_transaction_set_control_number", rollover_transaction_set_control_number)
        if sender_application_id is not None:
            pulumi.set(__self__, "sender_application_id", sender_application_id)
        if transaction_set_control_number_lower_bound is not None:
            pulumi.set(__self__, "transaction_set_control_number_lower_bound", transaction_set_control_number_lower_bound)
        if transaction_set_control_number_prefix is not None:
            pulumi.set(__self__, "transaction_set_control_number_prefix", transaction_set_control_number_prefix)
        if transaction_set_control_number_suffix is not None:
            pulumi.set(__self__, "transaction_set_control_number_suffix", transaction_set_control_number_suffix)
        if transaction_set_control_number_upper_bound is not None:
            pulumi.set(__self__, "transaction_set_control_number_upper_bound", transaction_set_control_number_upper_bound)
        if usage_indicator is not None:
            pulumi.set(__self__, "usage_indicator", usage_indicator)
        if use_control_standards_id_as_repetition_character is not None:
            pulumi.set(__self__, "use_control_standards_id_as_repetition_character", use_control_standards_id_as_repetition_character)

    @property
    @pulumi.getter(name="controlStandardsId")
    def control_standards_id(self) -> Optional[pulumi.Input[int]]:
        """
        The controls standards id.
        """
        return pulumi.get(self, "control_standards_id")

    @control_standards_id.setter
    def control_standards_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "control_standards_id", value)

    @property
    @pulumi.getter(name="controlVersionNumber")
    def control_version_number(self) -> Optional[pulumi.Input[str]]:
        """
        The control version number.
        """
        return pulumi.get(self, "control_version_number")

    @control_version_number.setter
    def control_version_number(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "control_version_number", value)

    @property
    @pulumi.getter(name="enableDefaultGroupHeaders")
    def enable_default_group_headers(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to enable default group headers.
        """
        return pulumi.get(self, "enable_default_group_headers")

    @enable_default_group_headers.setter
    def enable_default_group_headers(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_default_group_headers", value)

    @property
    @pulumi.getter(name="functionalGroupId")
    def functional_group_id(self) -> Optional[pulumi.Input[str]]:
        """
        The functional group id.
        """
        return pulumi.get(self, "functional_group_id")

    @functional_group_id.setter
    def functional_group_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "functional_group_id", value)

    @property
    @pulumi.getter(name="groupControlNumberLowerBound")
    def group_control_number_lower_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The group control number lower bound.
        """
        return pulumi.get(self, "group_control_number_lower_bound")

    @group_control_number_lower_bound.setter
    def group_control_number_lower_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "group_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="groupControlNumberUpperBound")
    def group_control_number_upper_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The group control number upper bound.
        """
        return pulumi.get(self, "group_control_number_upper_bound")

    @group_control_number_upper_bound.setter
    def group_control_number_upper_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "group_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="groupHeaderAgencyCode")
    def group_header_agency_code(self) -> Optional[pulumi.Input[str]]:
        """
        The group header agency code.
        """
        return pulumi.get(self, "group_header_agency_code")

    @group_header_agency_code.setter
    def group_header_agency_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_header_agency_code", value)

    @property
    @pulumi.getter(name="groupHeaderDateFormat")
    def group_header_date_format(self) -> Optional[pulumi.Input['X12DateFormat']]:
        """
        The group header date format.
        """
        return pulumi.get(self, "group_header_date_format")

    @group_header_date_format.setter
    def group_header_date_format(self, value: Optional[pulumi.Input['X12DateFormat']]):
        pulumi.set(self, "group_header_date_format", value)

    @property
    @pulumi.getter(name="groupHeaderTimeFormat")
    def group_header_time_format(self) -> Optional[pulumi.Input['X12TimeFormat']]:
        """
        The group header time format.
        """
        return pulumi.get(self, "group_header_time_format")

    @group_header_time_format.setter
    def group_header_time_format(self, value: Optional[pulumi.Input['X12TimeFormat']]):
        pulumi.set(self, "group_header_time_format", value)

    @property
    @pulumi.getter(name="groupHeaderVersion")
    def group_header_version(self) -> Optional[pulumi.Input[str]]:
        """
        The group header version.
        """
        return pulumi.get(self, "group_header_version")

    @group_header_version.setter
    def group_header_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_header_version", value)

    @property
    @pulumi.getter(name="interchangeControlNumberLowerBound")
    def interchange_control_number_lower_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The interchange  control number lower bound.
        """
        return pulumi.get(self, "interchange_control_number_lower_bound")

    @interchange_control_number_lower_bound.setter
    def interchange_control_number_lower_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interchange_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="interchangeControlNumberUpperBound")
    def interchange_control_number_upper_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The interchange  control number upper bound.
        """
        return pulumi.get(self, "interchange_control_number_upper_bound")

    @interchange_control_number_upper_bound.setter
    def interchange_control_number_upper_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interchange_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="overwriteExistingTransactionSetControlNumber")
    def overwrite_existing_transaction_set_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to overwrite existing transaction set control number.
        """
        return pulumi.get(self, "overwrite_existing_transaction_set_control_number")

    @overwrite_existing_transaction_set_control_number.setter
    def overwrite_existing_transaction_set_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "overwrite_existing_transaction_set_control_number", value)

    @property
    @pulumi.getter(name="receiverApplicationId")
    def receiver_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The receiver application id.
        """
        return pulumi.get(self, "receiver_application_id")

    @receiver_application_id.setter
    def receiver_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "receiver_application_id", value)

    @property
    @pulumi.getter(name="rolloverGroupControlNumber")
    def rollover_group_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover group control number.
        """
        return pulumi.get(self, "rollover_group_control_number")

    @rollover_group_control_number.setter
    def rollover_group_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_group_control_number", value)

    @property
    @pulumi.getter(name="rolloverInterchangeControlNumber")
    def rollover_interchange_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover interchange control number.
        """
        return pulumi.get(self, "rollover_interchange_control_number")

    @rollover_interchange_control_number.setter
    def rollover_interchange_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_interchange_control_number", value)

    @property
    @pulumi.getter(name="rolloverTransactionSetControlNumber")
    def rollover_transaction_set_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to rollover transaction set control number.
        """
        return pulumi.get(self, "rollover_transaction_set_control_number")

    @rollover_transaction_set_control_number.setter
    def rollover_transaction_set_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rollover_transaction_set_control_number", value)

    @property
    @pulumi.getter(name="senderApplicationId")
    def sender_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application id.
        """
        return pulumi.get(self, "sender_application_id")

    @sender_application_id.setter
    def sender_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_id", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberLowerBound")
    def transaction_set_control_number_lower_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The transaction set control number lower bound.
        """
        return pulumi.get(self, "transaction_set_control_number_lower_bound")

    @transaction_set_control_number_lower_bound.setter
    def transaction_set_control_number_lower_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "transaction_set_control_number_lower_bound", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberPrefix")
    def transaction_set_control_number_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        The transaction set control number prefix.
        """
        return pulumi.get(self, "transaction_set_control_number_prefix")

    @transaction_set_control_number_prefix.setter
    def transaction_set_control_number_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "transaction_set_control_number_prefix", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberSuffix")
    def transaction_set_control_number_suffix(self) -> Optional[pulumi.Input[str]]:
        """
        The transaction set control number suffix.
        """
        return pulumi.get(self, "transaction_set_control_number_suffix")

    @transaction_set_control_number_suffix.setter
    def transaction_set_control_number_suffix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "transaction_set_control_number_suffix", value)

    @property
    @pulumi.getter(name="transactionSetControlNumberUpperBound")
    def transaction_set_control_number_upper_bound(self) -> Optional[pulumi.Input[int]]:
        """
        The transaction set control number upper bound.
        """
        return pulumi.get(self, "transaction_set_control_number_upper_bound")

    @transaction_set_control_number_upper_bound.setter
    def transaction_set_control_number_upper_bound(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "transaction_set_control_number_upper_bound", value)

    @property
    @pulumi.getter(name="usageIndicator")
    def usage_indicator(self) -> Optional[pulumi.Input['UsageIndicator']]:
        """
        The usage indicator.
        """
        return pulumi.get(self, "usage_indicator")

    @usage_indicator.setter
    def usage_indicator(self, value: Optional[pulumi.Input['UsageIndicator']]):
        pulumi.set(self, "usage_indicator", value)

    @property
    @pulumi.getter(name="useControlStandardsIdAsRepetitionCharacter")
    def use_control_standards_id_as_repetition_character(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to use control standards id as repetition character.
        """
        return pulumi.get(self, "use_control_standards_id_as_repetition_character")

    @use_control_standards_id_as_repetition_character.setter
    def use_control_standards_id_as_repetition_character(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_control_standards_id_as_repetition_character", value)


@pulumi.input_type
class X12FramingSettingsArgs:
    def __init__(__self__, *,
                 character_set: Optional[pulumi.Input['X12CharacterSet']] = None,
                 component_separator: Optional[pulumi.Input[int]] = None,
                 data_element_separator: Optional[pulumi.Input[int]] = None,
                 replace_character: Optional[pulumi.Input[int]] = None,
                 replace_separators_in_payload: Optional[pulumi.Input[bool]] = None,
                 segment_terminator: Optional[pulumi.Input[int]] = None,
                 segment_terminator_suffix: Optional[pulumi.Input['SegmentTerminatorSuffix']] = None):
        """
        :param pulumi.Input['X12CharacterSet'] character_set: The X12 character set.
        :param pulumi.Input[int] component_separator: The component separator.
        :param pulumi.Input[int] data_element_separator: The data element separator.
        :param pulumi.Input[int] replace_character: The replacement character.
        :param pulumi.Input[bool] replace_separators_in_payload: The value indicating whether to replace separators in payload.
        :param pulumi.Input[int] segment_terminator: The segment terminator.
        :param pulumi.Input['SegmentTerminatorSuffix'] segment_terminator_suffix: The segment terminator suffix.
        """
        if character_set is not None:
            pulumi.set(__self__, "character_set", character_set)
        if component_separator is not None:
            pulumi.set(__self__, "component_separator", component_separator)
        if data_element_separator is not None:
            pulumi.set(__self__, "data_element_separator", data_element_separator)
        if replace_character is not None:
            pulumi.set(__self__, "replace_character", replace_character)
        if replace_separators_in_payload is not None:
            pulumi.set(__self__, "replace_separators_in_payload", replace_separators_in_payload)
        if segment_terminator is not None:
            pulumi.set(__self__, "segment_terminator", segment_terminator)
        if segment_terminator_suffix is not None:
            pulumi.set(__self__, "segment_terminator_suffix", segment_terminator_suffix)

    @property
    @pulumi.getter(name="characterSet")
    def character_set(self) -> Optional[pulumi.Input['X12CharacterSet']]:
        """
        The X12 character set.
        """
        return pulumi.get(self, "character_set")

    @character_set.setter
    def character_set(self, value: Optional[pulumi.Input['X12CharacterSet']]):
        pulumi.set(self, "character_set", value)

    @property
    @pulumi.getter(name="componentSeparator")
    def component_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The component separator.
        """
        return pulumi.get(self, "component_separator")

    @component_separator.setter
    def component_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "component_separator", value)

    @property
    @pulumi.getter(name="dataElementSeparator")
    def data_element_separator(self) -> Optional[pulumi.Input[int]]:
        """
        The data element separator.
        """
        return pulumi.get(self, "data_element_separator")

    @data_element_separator.setter
    def data_element_separator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "data_element_separator", value)

    @property
    @pulumi.getter(name="replaceCharacter")
    def replace_character(self) -> Optional[pulumi.Input[int]]:
        """
        The replacement character.
        """
        return pulumi.get(self, "replace_character")

    @replace_character.setter
    def replace_character(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "replace_character", value)

    @property
    @pulumi.getter(name="replaceSeparatorsInPayload")
    def replace_separators_in_payload(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to replace separators in payload.
        """
        return pulumi.get(self, "replace_separators_in_payload")

    @replace_separators_in_payload.setter
    def replace_separators_in_payload(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "replace_separators_in_payload", value)

    @property
    @pulumi.getter(name="segmentTerminator")
    def segment_terminator(self) -> Optional[pulumi.Input[int]]:
        """
        The segment terminator.
        """
        return pulumi.get(self, "segment_terminator")

    @segment_terminator.setter
    def segment_terminator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "segment_terminator", value)

    @property
    @pulumi.getter(name="segmentTerminatorSuffix")
    def segment_terminator_suffix(self) -> Optional[pulumi.Input['SegmentTerminatorSuffix']]:
        """
        The segment terminator suffix.
        """
        return pulumi.get(self, "segment_terminator_suffix")

    @segment_terminator_suffix.setter
    def segment_terminator_suffix(self, value: Optional[pulumi.Input['SegmentTerminatorSuffix']]):
        pulumi.set(self, "segment_terminator_suffix", value)


@pulumi.input_type
class X12MessageFilterArgs:
    def __init__(__self__, *,
                 message_filter_type: Optional[pulumi.Input['MessageFilterType']] = None):
        """
        :param pulumi.Input['MessageFilterType'] message_filter_type: The message filter type.
        """
        if message_filter_type is not None:
            pulumi.set(__self__, "message_filter_type", message_filter_type)

    @property
    @pulumi.getter(name="messageFilterType")
    def message_filter_type(self) -> Optional[pulumi.Input['MessageFilterType']]:
        """
        The message filter type.
        """
        return pulumi.get(self, "message_filter_type")

    @message_filter_type.setter
    def message_filter_type(self, value: Optional[pulumi.Input['MessageFilterType']]):
        pulumi.set(self, "message_filter_type", value)


@pulumi.input_type
class X12MessageIdentifierArgs:
    def __init__(__self__, *,
                 message_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] message_id: The message id.
        """
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)


@pulumi.input_type
class X12OneWayAgreementArgs:
    def __init__(__self__, *,
                 protocol_settings: Optional[pulumi.Input['X12ProtocolSettingsArgs']] = None,
                 receiver_business_identity: Optional[pulumi.Input['BusinessIdentityArgs']] = None,
                 sender_business_identity: Optional[pulumi.Input['BusinessIdentityArgs']] = None):
        """
        :param pulumi.Input['X12ProtocolSettingsArgs'] protocol_settings: The X12 protocol settings.
        :param pulumi.Input['BusinessIdentityArgs'] receiver_business_identity: The receiver business identity
        :param pulumi.Input['BusinessIdentityArgs'] sender_business_identity: The sender business identity
        """
        if protocol_settings is not None:
            pulumi.set(__self__, "protocol_settings", protocol_settings)
        if receiver_business_identity is not None:
            pulumi.set(__self__, "receiver_business_identity", receiver_business_identity)
        if sender_business_identity is not None:
            pulumi.set(__self__, "sender_business_identity", sender_business_identity)

    @property
    @pulumi.getter(name="protocolSettings")
    def protocol_settings(self) -> Optional[pulumi.Input['X12ProtocolSettingsArgs']]:
        """
        The X12 protocol settings.
        """
        return pulumi.get(self, "protocol_settings")

    @protocol_settings.setter
    def protocol_settings(self, value: Optional[pulumi.Input['X12ProtocolSettingsArgs']]):
        pulumi.set(self, "protocol_settings", value)

    @property
    @pulumi.getter(name="receiverBusinessIdentity")
    def receiver_business_identity(self) -> Optional[pulumi.Input['BusinessIdentityArgs']]:
        """
        The receiver business identity
        """
        return pulumi.get(self, "receiver_business_identity")

    @receiver_business_identity.setter
    def receiver_business_identity(self, value: Optional[pulumi.Input['BusinessIdentityArgs']]):
        pulumi.set(self, "receiver_business_identity", value)

    @property
    @pulumi.getter(name="senderBusinessIdentity")
    def sender_business_identity(self) -> Optional[pulumi.Input['BusinessIdentityArgs']]:
        """
        The sender business identity
        """
        return pulumi.get(self, "sender_business_identity")

    @sender_business_identity.setter
    def sender_business_identity(self, value: Optional[pulumi.Input['BusinessIdentityArgs']]):
        pulumi.set(self, "sender_business_identity", value)


@pulumi.input_type
class X12ProcessingSettingsArgs:
    def __init__(__self__, *,
                 convert_implied_decimal: Optional[pulumi.Input[bool]] = None,
                 create_empty_xml_tags_for_trailing_separators: Optional[pulumi.Input[bool]] = None,
                 mask_security_info: Optional[pulumi.Input[bool]] = None,
                 preserve_interchange: Optional[pulumi.Input[bool]] = None,
                 suspend_interchange_on_error: Optional[pulumi.Input[bool]] = None,
                 use_dot_as_decimal_separator: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] convert_implied_decimal: The value indicating whether to convert numerical type to implied decimal.
        :param pulumi.Input[bool] create_empty_xml_tags_for_trailing_separators: The value indicating whether to create empty xml tags for trailing separators.
        :param pulumi.Input[bool] mask_security_info: The value indicating whether to mask security information.
        :param pulumi.Input[bool] preserve_interchange: The value indicating whether to preserve interchange.
        :param pulumi.Input[bool] suspend_interchange_on_error: The value indicating whether to suspend interchange on error.
        :param pulumi.Input[bool] use_dot_as_decimal_separator: The value indicating whether to use dot as decimal separator.
        """
        if convert_implied_decimal is not None:
            pulumi.set(__self__, "convert_implied_decimal", convert_implied_decimal)
        if create_empty_xml_tags_for_trailing_separators is not None:
            pulumi.set(__self__, "create_empty_xml_tags_for_trailing_separators", create_empty_xml_tags_for_trailing_separators)
        if mask_security_info is not None:
            pulumi.set(__self__, "mask_security_info", mask_security_info)
        if preserve_interchange is not None:
            pulumi.set(__self__, "preserve_interchange", preserve_interchange)
        if suspend_interchange_on_error is not None:
            pulumi.set(__self__, "suspend_interchange_on_error", suspend_interchange_on_error)
        if use_dot_as_decimal_separator is not None:
            pulumi.set(__self__, "use_dot_as_decimal_separator", use_dot_as_decimal_separator)

    @property
    @pulumi.getter(name="convertImpliedDecimal")
    def convert_implied_decimal(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to convert numerical type to implied decimal.
        """
        return pulumi.get(self, "convert_implied_decimal")

    @convert_implied_decimal.setter
    def convert_implied_decimal(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "convert_implied_decimal", value)

    @property
    @pulumi.getter(name="createEmptyXmlTagsForTrailingSeparators")
    def create_empty_xml_tags_for_trailing_separators(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to create empty xml tags for trailing separators.
        """
        return pulumi.get(self, "create_empty_xml_tags_for_trailing_separators")

    @create_empty_xml_tags_for_trailing_separators.setter
    def create_empty_xml_tags_for_trailing_separators(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "create_empty_xml_tags_for_trailing_separators", value)

    @property
    @pulumi.getter(name="maskSecurityInfo")
    def mask_security_info(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to mask security information.
        """
        return pulumi.get(self, "mask_security_info")

    @mask_security_info.setter
    def mask_security_info(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mask_security_info", value)

    @property
    @pulumi.getter(name="preserveInterchange")
    def preserve_interchange(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to preserve interchange.
        """
        return pulumi.get(self, "preserve_interchange")

    @preserve_interchange.setter
    def preserve_interchange(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "preserve_interchange", value)

    @property
    @pulumi.getter(name="suspendInterchangeOnError")
    def suspend_interchange_on_error(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to suspend interchange on error.
        """
        return pulumi.get(self, "suspend_interchange_on_error")

    @suspend_interchange_on_error.setter
    def suspend_interchange_on_error(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "suspend_interchange_on_error", value)

    @property
    @pulumi.getter(name="useDotAsDecimalSeparator")
    def use_dot_as_decimal_separator(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to use dot as decimal separator.
        """
        return pulumi.get(self, "use_dot_as_decimal_separator")

    @use_dot_as_decimal_separator.setter
    def use_dot_as_decimal_separator(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_dot_as_decimal_separator", value)


@pulumi.input_type
class X12ProtocolSettingsArgs:
    def __init__(__self__, *,
                 acknowledgement_settings: Optional[pulumi.Input['X12AcknowledgementSettingsArgs']] = None,
                 envelope_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['X12EnvelopeOverrideArgs']]]] = None,
                 envelope_settings: Optional[pulumi.Input['X12EnvelopeSettingsArgs']] = None,
                 framing_settings: Optional[pulumi.Input['X12FramingSettingsArgs']] = None,
                 message_filter: Optional[pulumi.Input['X12MessageFilterArgs']] = None,
                 message_filter_list: Optional[pulumi.Input[Sequence[pulumi.Input['X12MessageIdentifierArgs']]]] = None,
                 processing_settings: Optional[pulumi.Input['X12ProcessingSettingsArgs']] = None,
                 schema_references: Optional[pulumi.Input[Sequence[pulumi.Input['X12SchemaReferenceArgs']]]] = None,
                 security_settings: Optional[pulumi.Input['X12SecuritySettingsArgs']] = None,
                 validation_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['X12ValidationOverrideArgs']]]] = None,
                 validation_settings: Optional[pulumi.Input['X12ValidationSettingsArgs']] = None,
                 x12_delimiter_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['X12DelimiterOverridesArgs']]]] = None):
        """
        :param pulumi.Input['X12AcknowledgementSettingsArgs'] acknowledgement_settings: The X12 acknowledgment settings.
        :param pulumi.Input[Sequence[pulumi.Input['X12EnvelopeOverrideArgs']]] envelope_overrides: The X12 envelope override settings.
        :param pulumi.Input['X12EnvelopeSettingsArgs'] envelope_settings: The X12 envelope settings.
        :param pulumi.Input['X12FramingSettingsArgs'] framing_settings: The X12 framing settings.
        :param pulumi.Input['X12MessageFilterArgs'] message_filter: The X12 message filter.
        :param pulumi.Input[Sequence[pulumi.Input['X12MessageIdentifierArgs']]] message_filter_list: The X12 message filter list.
        :param pulumi.Input['X12ProcessingSettingsArgs'] processing_settings: The X12 processing settings.
        :param pulumi.Input[Sequence[pulumi.Input['X12SchemaReferenceArgs']]] schema_references: The X12 schema references.
        :param pulumi.Input['X12SecuritySettingsArgs'] security_settings: The X12 security settings.
        :param pulumi.Input[Sequence[pulumi.Input['X12ValidationOverrideArgs']]] validation_overrides: The X12 validation override settings.
        :param pulumi.Input['X12ValidationSettingsArgs'] validation_settings: The X12 validation settings.
        :param pulumi.Input[Sequence[pulumi.Input['X12DelimiterOverridesArgs']]] x12_delimiter_overrides: The X12 delimiter override settings.
        """
        if acknowledgement_settings is not None:
            pulumi.set(__self__, "acknowledgement_settings", acknowledgement_settings)
        if envelope_overrides is not None:
            pulumi.set(__self__, "envelope_overrides", envelope_overrides)
        if envelope_settings is not None:
            pulumi.set(__self__, "envelope_settings", envelope_settings)
        if framing_settings is not None:
            pulumi.set(__self__, "framing_settings", framing_settings)
        if message_filter is not None:
            pulumi.set(__self__, "message_filter", message_filter)
        if message_filter_list is not None:
            pulumi.set(__self__, "message_filter_list", message_filter_list)
        if processing_settings is not None:
            pulumi.set(__self__, "processing_settings", processing_settings)
        if schema_references is not None:
            pulumi.set(__self__, "schema_references", schema_references)
        if security_settings is not None:
            pulumi.set(__self__, "security_settings", security_settings)
        if validation_overrides is not None:
            pulumi.set(__self__, "validation_overrides", validation_overrides)
        if validation_settings is not None:
            pulumi.set(__self__, "validation_settings", validation_settings)
        if x12_delimiter_overrides is not None:
            pulumi.set(__self__, "x12_delimiter_overrides", x12_delimiter_overrides)

    @property
    @pulumi.getter(name="acknowledgementSettings")
    def acknowledgement_settings(self) -> Optional[pulumi.Input['X12AcknowledgementSettingsArgs']]:
        """
        The X12 acknowledgment settings.
        """
        return pulumi.get(self, "acknowledgement_settings")

    @acknowledgement_settings.setter
    def acknowledgement_settings(self, value: Optional[pulumi.Input['X12AcknowledgementSettingsArgs']]):
        pulumi.set(self, "acknowledgement_settings", value)

    @property
    @pulumi.getter(name="envelopeOverrides")
    def envelope_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['X12EnvelopeOverrideArgs']]]]:
        """
        The X12 envelope override settings.
        """
        return pulumi.get(self, "envelope_overrides")

    @envelope_overrides.setter
    def envelope_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['X12EnvelopeOverrideArgs']]]]):
        pulumi.set(self, "envelope_overrides", value)

    @property
    @pulumi.getter(name="envelopeSettings")
    def envelope_settings(self) -> Optional[pulumi.Input['X12EnvelopeSettingsArgs']]:
        """
        The X12 envelope settings.
        """
        return pulumi.get(self, "envelope_settings")

    @envelope_settings.setter
    def envelope_settings(self, value: Optional[pulumi.Input['X12EnvelopeSettingsArgs']]):
        pulumi.set(self, "envelope_settings", value)

    @property
    @pulumi.getter(name="framingSettings")
    def framing_settings(self) -> Optional[pulumi.Input['X12FramingSettingsArgs']]:
        """
        The X12 framing settings.
        """
        return pulumi.get(self, "framing_settings")

    @framing_settings.setter
    def framing_settings(self, value: Optional[pulumi.Input['X12FramingSettingsArgs']]):
        pulumi.set(self, "framing_settings", value)

    @property
    @pulumi.getter(name="messageFilter")
    def message_filter(self) -> Optional[pulumi.Input['X12MessageFilterArgs']]:
        """
        The X12 message filter.
        """
        return pulumi.get(self, "message_filter")

    @message_filter.setter
    def message_filter(self, value: Optional[pulumi.Input['X12MessageFilterArgs']]):
        pulumi.set(self, "message_filter", value)

    @property
    @pulumi.getter(name="messageFilterList")
    def message_filter_list(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['X12MessageIdentifierArgs']]]]:
        """
        The X12 message filter list.
        """
        return pulumi.get(self, "message_filter_list")

    @message_filter_list.setter
    def message_filter_list(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['X12MessageIdentifierArgs']]]]):
        pulumi.set(self, "message_filter_list", value)

    @property
    @pulumi.getter(name="processingSettings")
    def processing_settings(self) -> Optional[pulumi.Input['X12ProcessingSettingsArgs']]:
        """
        The X12 processing settings.
        """
        return pulumi.get(self, "processing_settings")

    @processing_settings.setter
    def processing_settings(self, value: Optional[pulumi.Input['X12ProcessingSettingsArgs']]):
        pulumi.set(self, "processing_settings", value)

    @property
    @pulumi.getter(name="schemaReferences")
    def schema_references(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['X12SchemaReferenceArgs']]]]:
        """
        The X12 schema references.
        """
        return pulumi.get(self, "schema_references")

    @schema_references.setter
    def schema_references(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['X12SchemaReferenceArgs']]]]):
        pulumi.set(self, "schema_references", value)

    @property
    @pulumi.getter(name="securitySettings")
    def security_settings(self) -> Optional[pulumi.Input['X12SecuritySettingsArgs']]:
        """
        The X12 security settings.
        """
        return pulumi.get(self, "security_settings")

    @security_settings.setter
    def security_settings(self, value: Optional[pulumi.Input['X12SecuritySettingsArgs']]):
        pulumi.set(self, "security_settings", value)

    @property
    @pulumi.getter(name="validationOverrides")
    def validation_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['X12ValidationOverrideArgs']]]]:
        """
        The X12 validation override settings.
        """
        return pulumi.get(self, "validation_overrides")

    @validation_overrides.setter
    def validation_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['X12ValidationOverrideArgs']]]]):
        pulumi.set(self, "validation_overrides", value)

    @property
    @pulumi.getter(name="validationSettings")
    def validation_settings(self) -> Optional[pulumi.Input['X12ValidationSettingsArgs']]:
        """
        The X12 validation settings.
        """
        return pulumi.get(self, "validation_settings")

    @validation_settings.setter
    def validation_settings(self, value: Optional[pulumi.Input['X12ValidationSettingsArgs']]):
        pulumi.set(self, "validation_settings", value)

    @property
    @pulumi.getter(name="x12DelimiterOverrides")
    def x12_delimiter_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['X12DelimiterOverridesArgs']]]]:
        """
        The X12 delimiter override settings.
        """
        return pulumi.get(self, "x12_delimiter_overrides")

    @x12_delimiter_overrides.setter
    def x12_delimiter_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['X12DelimiterOverridesArgs']]]]):
        pulumi.set(self, "x12_delimiter_overrides", value)


@pulumi.input_type
class X12SchemaReferenceArgs:
    def __init__(__self__, *,
                 message_id: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None,
                 schema_version: Optional[pulumi.Input[str]] = None,
                 sender_application_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] message_id: The message id.
        :param pulumi.Input[str] schema_name: The schema name.
        :param pulumi.Input[str] schema_version: The schema version.
        :param pulumi.Input[str] sender_application_id: The sender application id.
        """
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if schema_version is not None:
            pulumi.set(__self__, "schema_version", schema_version)
        if sender_application_id is not None:
            pulumi.set(__self__, "sender_application_id", sender_application_id)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[pulumi.Input[str]]:
        """
        The schema name.
        """
        return pulumi.get(self, "schema_name")

    @schema_name.setter
    def schema_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schema_name", value)

    @property
    @pulumi.getter(name="schemaVersion")
    def schema_version(self) -> Optional[pulumi.Input[str]]:
        """
        The schema version.
        """
        return pulumi.get(self, "schema_version")

    @schema_version.setter
    def schema_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schema_version", value)

    @property
    @pulumi.getter(name="senderApplicationId")
    def sender_application_id(self) -> Optional[pulumi.Input[str]]:
        """
        The sender application id.
        """
        return pulumi.get(self, "sender_application_id")

    @sender_application_id.setter
    def sender_application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sender_application_id", value)


@pulumi.input_type
class X12SecuritySettingsArgs:
    def __init__(__self__, *,
                 authorization_qualifier: Optional[pulumi.Input[str]] = None,
                 authorization_value: Optional[pulumi.Input[str]] = None,
                 password_value: Optional[pulumi.Input[str]] = None,
                 security_qualifier: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] authorization_qualifier: The authorization qualifier.
        :param pulumi.Input[str] authorization_value: The authorization value.
        :param pulumi.Input[str] password_value: The password value.
        :param pulumi.Input[str] security_qualifier: The security qualifier.
        """
        if authorization_qualifier is not None:
            pulumi.set(__self__, "authorization_qualifier", authorization_qualifier)
        if authorization_value is not None:
            pulumi.set(__self__, "authorization_value", authorization_value)
        if password_value is not None:
            pulumi.set(__self__, "password_value", password_value)
        if security_qualifier is not None:
            pulumi.set(__self__, "security_qualifier", security_qualifier)

    @property
    @pulumi.getter(name="authorizationQualifier")
    def authorization_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The authorization qualifier.
        """
        return pulumi.get(self, "authorization_qualifier")

    @authorization_qualifier.setter
    def authorization_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "authorization_qualifier", value)

    @property
    @pulumi.getter(name="authorizationValue")
    def authorization_value(self) -> Optional[pulumi.Input[str]]:
        """
        The authorization value.
        """
        return pulumi.get(self, "authorization_value")

    @authorization_value.setter
    def authorization_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "authorization_value", value)

    @property
    @pulumi.getter(name="passwordValue")
    def password_value(self) -> Optional[pulumi.Input[str]]:
        """
        The password value.
        """
        return pulumi.get(self, "password_value")

    @password_value.setter
    def password_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password_value", value)

    @property
    @pulumi.getter(name="securityQualifier")
    def security_qualifier(self) -> Optional[pulumi.Input[str]]:
        """
        The security qualifier.
        """
        return pulumi.get(self, "security_qualifier")

    @security_qualifier.setter
    def security_qualifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "security_qualifier", value)


@pulumi.input_type
class X12ValidationOverrideArgs:
    def __init__(__self__, *,
                 allow_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 message_id: Optional[pulumi.Input[str]] = None,
                 trailing_separator_policy: Optional[pulumi.Input['TrailingSeparatorPolicy']] = None,
                 trim_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 validate_character_set: Optional[pulumi.Input[bool]] = None,
                 validate_edi_types: Optional[pulumi.Input[bool]] = None,
                 validate_xsd_types: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] allow_leading_and_trailing_spaces_and_zeroes: The value indicating whether to allow leading and trailing spaces and zeroes.
        :param pulumi.Input[str] message_id: The message id on which the validation settings has to be applied.
        :param pulumi.Input['TrailingSeparatorPolicy'] trailing_separator_policy: The trailing separator policy.
        :param pulumi.Input[bool] trim_leading_and_trailing_spaces_and_zeroes: The value indicating whether to trim leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] validate_character_set: The value indicating whether to validate character Set.
        :param pulumi.Input[bool] validate_edi_types: The value indicating whether to validate EDI types.
        :param pulumi.Input[bool] validate_xsd_types: The value indicating whether to validate XSD types.
        """
        if allow_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "allow_leading_and_trailing_spaces_and_zeroes", allow_leading_and_trailing_spaces_and_zeroes)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)
        if trailing_separator_policy is not None:
            pulumi.set(__self__, "trailing_separator_policy", trailing_separator_policy)
        if trim_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "trim_leading_and_trailing_spaces_and_zeroes", trim_leading_and_trailing_spaces_and_zeroes)
        if validate_character_set is not None:
            pulumi.set(__self__, "validate_character_set", validate_character_set)
        if validate_edi_types is not None:
            pulumi.set(__self__, "validate_edi_types", validate_edi_types)
        if validate_xsd_types is not None:
            pulumi.set(__self__, "validate_xsd_types", validate_xsd_types)

    @property
    @pulumi.getter(name="allowLeadingAndTrailingSpacesAndZeroes")
    def allow_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to allow leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "allow_leading_and_trailing_spaces_and_zeroes")

    @allow_leading_and_trailing_spaces_and_zeroes.setter
    def allow_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[pulumi.Input[str]]:
        """
        The message id on which the validation settings has to be applied.
        """
        return pulumi.get(self, "message_id")

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)

    @property
    @pulumi.getter(name="trailingSeparatorPolicy")
    def trailing_separator_policy(self) -> Optional[pulumi.Input['TrailingSeparatorPolicy']]:
        """
        The trailing separator policy.
        """
        return pulumi.get(self, "trailing_separator_policy")

    @trailing_separator_policy.setter
    def trailing_separator_policy(self, value: Optional[pulumi.Input['TrailingSeparatorPolicy']]):
        pulumi.set(self, "trailing_separator_policy", value)

    @property
    @pulumi.getter(name="trimLeadingAndTrailingSpacesAndZeroes")
    def trim_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to trim leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "trim_leading_and_trailing_spaces_and_zeroes")

    @trim_leading_and_trailing_spaces_and_zeroes.setter
    def trim_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "trim_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="validateCharacterSet")
    def validate_character_set(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate character Set.
        """
        return pulumi.get(self, "validate_character_set")

    @validate_character_set.setter
    def validate_character_set(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_character_set", value)

    @property
    @pulumi.getter(name="validateEDITypes")
    def validate_edi_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate EDI types.
        """
        return pulumi.get(self, "validate_edi_types")

    @validate_edi_types.setter
    def validate_edi_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_edi_types", value)

    @property
    @pulumi.getter(name="validateXSDTypes")
    def validate_xsd_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate XSD types.
        """
        return pulumi.get(self, "validate_xsd_types")

    @validate_xsd_types.setter
    def validate_xsd_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_xsd_types", value)


@pulumi.input_type
class X12ValidationSettingsArgs:
    def __init__(__self__, *,
                 allow_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_group_control_number: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_interchange_control_number: Optional[pulumi.Input[bool]] = None,
                 check_duplicate_transaction_set_control_number: Optional[pulumi.Input[bool]] = None,
                 interchange_control_number_validity_days: Optional[pulumi.Input[int]] = None,
                 trailing_separator_policy: Optional[pulumi.Input['TrailingSeparatorPolicy']] = None,
                 trim_leading_and_trailing_spaces_and_zeroes: Optional[pulumi.Input[bool]] = None,
                 validate_character_set: Optional[pulumi.Input[bool]] = None,
                 validate_edi_types: Optional[pulumi.Input[bool]] = None,
                 validate_xsd_types: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] allow_leading_and_trailing_spaces_and_zeroes: The value indicating whether to allow leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] check_duplicate_group_control_number: The value indicating whether to check for duplicate group control number.
        :param pulumi.Input[bool] check_duplicate_interchange_control_number: The value indicating whether to check for duplicate interchange control number.
        :param pulumi.Input[bool] check_duplicate_transaction_set_control_number: The value indicating whether to check for duplicate transaction set control number.
        :param pulumi.Input[int] interchange_control_number_validity_days: The validity period of interchange control number.
        :param pulumi.Input['TrailingSeparatorPolicy'] trailing_separator_policy: The trailing separator policy.
        :param pulumi.Input[bool] trim_leading_and_trailing_spaces_and_zeroes: The value indicating whether to trim leading and trailing spaces and zeroes.
        :param pulumi.Input[bool] validate_character_set: The value indicating whether to validate character set in the message.
        :param pulumi.Input[bool] validate_edi_types: The value indicating whether to Whether to validate EDI types.
        :param pulumi.Input[bool] validate_xsd_types: The value indicating whether to Whether to validate XSD types.
        """
        if allow_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "allow_leading_and_trailing_spaces_and_zeroes", allow_leading_and_trailing_spaces_and_zeroes)
        if check_duplicate_group_control_number is not None:
            pulumi.set(__self__, "check_duplicate_group_control_number", check_duplicate_group_control_number)
        if check_duplicate_interchange_control_number is not None:
            pulumi.set(__self__, "check_duplicate_interchange_control_number", check_duplicate_interchange_control_number)
        if check_duplicate_transaction_set_control_number is not None:
            pulumi.set(__self__, "check_duplicate_transaction_set_control_number", check_duplicate_transaction_set_control_number)
        if interchange_control_number_validity_days is not None:
            pulumi.set(__self__, "interchange_control_number_validity_days", interchange_control_number_validity_days)
        if trailing_separator_policy is not None:
            pulumi.set(__self__, "trailing_separator_policy", trailing_separator_policy)
        if trim_leading_and_trailing_spaces_and_zeroes is not None:
            pulumi.set(__self__, "trim_leading_and_trailing_spaces_and_zeroes", trim_leading_and_trailing_spaces_and_zeroes)
        if validate_character_set is not None:
            pulumi.set(__self__, "validate_character_set", validate_character_set)
        if validate_edi_types is not None:
            pulumi.set(__self__, "validate_edi_types", validate_edi_types)
        if validate_xsd_types is not None:
            pulumi.set(__self__, "validate_xsd_types", validate_xsd_types)

    @property
    @pulumi.getter(name="allowLeadingAndTrailingSpacesAndZeroes")
    def allow_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to allow leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "allow_leading_and_trailing_spaces_and_zeroes")

    @allow_leading_and_trailing_spaces_and_zeroes.setter
    def allow_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="checkDuplicateGroupControlNumber")
    def check_duplicate_group_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate group control number.
        """
        return pulumi.get(self, "check_duplicate_group_control_number")

    @check_duplicate_group_control_number.setter
    def check_duplicate_group_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_group_control_number", value)

    @property
    @pulumi.getter(name="checkDuplicateInterchangeControlNumber")
    def check_duplicate_interchange_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate interchange control number.
        """
        return pulumi.get(self, "check_duplicate_interchange_control_number")

    @check_duplicate_interchange_control_number.setter
    def check_duplicate_interchange_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_interchange_control_number", value)

    @property
    @pulumi.getter(name="checkDuplicateTransactionSetControlNumber")
    def check_duplicate_transaction_set_control_number(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to check for duplicate transaction set control number.
        """
        return pulumi.get(self, "check_duplicate_transaction_set_control_number")

    @check_duplicate_transaction_set_control_number.setter
    def check_duplicate_transaction_set_control_number(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "check_duplicate_transaction_set_control_number", value)

    @property
    @pulumi.getter(name="interchangeControlNumberValidityDays")
    def interchange_control_number_validity_days(self) -> Optional[pulumi.Input[int]]:
        """
        The validity period of interchange control number.
        """
        return pulumi.get(self, "interchange_control_number_validity_days")

    @interchange_control_number_validity_days.setter
    def interchange_control_number_validity_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interchange_control_number_validity_days", value)

    @property
    @pulumi.getter(name="trailingSeparatorPolicy")
    def trailing_separator_policy(self) -> Optional[pulumi.Input['TrailingSeparatorPolicy']]:
        """
        The trailing separator policy.
        """
        return pulumi.get(self, "trailing_separator_policy")

    @trailing_separator_policy.setter
    def trailing_separator_policy(self, value: Optional[pulumi.Input['TrailingSeparatorPolicy']]):
        pulumi.set(self, "trailing_separator_policy", value)

    @property
    @pulumi.getter(name="trimLeadingAndTrailingSpacesAndZeroes")
    def trim_leading_and_trailing_spaces_and_zeroes(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to trim leading and trailing spaces and zeroes.
        """
        return pulumi.get(self, "trim_leading_and_trailing_spaces_and_zeroes")

    @trim_leading_and_trailing_spaces_and_zeroes.setter
    def trim_leading_and_trailing_spaces_and_zeroes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "trim_leading_and_trailing_spaces_and_zeroes", value)

    @property
    @pulumi.getter(name="validateCharacterSet")
    def validate_character_set(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to validate character set in the message.
        """
        return pulumi.get(self, "validate_character_set")

    @validate_character_set.setter
    def validate_character_set(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_character_set", value)

    @property
    @pulumi.getter(name="validateEDITypes")
    def validate_edi_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to Whether to validate EDI types.
        """
        return pulumi.get(self, "validate_edi_types")

    @validate_edi_types.setter
    def validate_edi_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_edi_types", value)

    @property
    @pulumi.getter(name="validateXSDTypes")
    def validate_xsd_types(self) -> Optional[pulumi.Input[bool]]:
        """
        The value indicating whether to Whether to validate XSD types.
        """
        return pulumi.get(self, "validate_xsd_types")

    @validate_xsd_types.setter
    def validate_xsd_types(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "validate_xsd_types", value)


