from reprlib import repr as limitedRepr


import enum
from typing import List


class VersionInfo(enum.Enum):
    """
    (Internal Only) Version information.
    """

    PROTOCOL_VERSION = "1.1.0"

    @staticmethod
    def from_dict(d):
        return VersionInfo(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum VersionInfo. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class ConnectRequest:
    """
    (Internal Only) Request object to connect to the service.
    """

    __slots__ = [
        "__request_id",
        "__protocol_version",
        "__other_supported_protocol_versions",
        "__sdk_version",
        "__auth_token",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "protocol_version": {"type": str, "subtype": None},
        "other_supported_protocol_versions": {"type": list, "subtype": str},
        "sdk_version": {"type": str, "subtype": None},
        "auth_token": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "protocol_version": {
            "required": True,
        },
        "other_supported_protocol_versions": {
            "required": False,
        },
        "sdk_version": {
            "required": False,
        },
        "auth_token": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        protocol_version: str = None,
        other_supported_protocol_versions: List[str] = None,
        sdk_version: str = None,
        auth_token: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__protocol_version = protocol_version
        self.__other_supported_protocol_versions = other_supported_protocol_versions
        self.__sdk_version = sdk_version
        self.__auth_token = auth_token

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_protocol_version(self):
        return self.__protocol_version

    def _set_protocol_version(self, value):
        if not isinstance(value, str):
            raise TypeError("protocol_version must be str")

        self.__protocol_version = value

    protocol_version = property(_get_protocol_version, _set_protocol_version)

    def _get_other_supported_protocol_versions(self):
        return self.__other_supported_protocol_versions

    def _set_other_supported_protocol_versions(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("other_supported_protocol_versions must be list")
        if value is not None and not all(isinstance(i, str) for i in value):
            raise TypeError("other_supported_protocol_versions list values must be str")

        self.__other_supported_protocol_versions = value

    other_supported_protocol_versions = property(
        _get_other_supported_protocol_versions, _set_other_supported_protocol_versions
    )

    def _get_sdk_version(self):
        return self.__sdk_version

    def _set_sdk_version(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("sdk_version must be str")

        self.__sdk_version = value

    sdk_version = property(_get_sdk_version, _set_sdk_version)

    def _get_auth_token(self):
        return self.__auth_token

    def _set_auth_token(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("auth_token must be str")

        self.__auth_token = value

    auth_token = property(_get_auth_token, _set_auth_token)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "protocolVersion" in d:
            v["protocol_version"] = (
                str.from_dict(d["protocolVersion"])
                if hasattr(str, "from_dict")
                else d["protocolVersion"]
            )
        if "otherSupportedProtocolVersions" in d:
            v["other_supported_protocol_versions"] = [
                str.from_dict(p) if hasattr(str, "from_dict") else p
                for p in d["otherSupportedProtocolVersions"]
            ]
        if "sdkVersion" in d:
            v["sdk_version"] = (
                str.from_dict(d["sdkVersion"])
                if hasattr(str, "from_dict")
                else d["sdkVersion"]
            )
        if "authToken" in d:
            v["auth_token"] = (
                str.from_dict(d["authToken"])
                if hasattr(str, "from_dict")
                else d["authToken"]
            )
        return ConnectRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__protocol_version is not None:
            d["protocolVersion"] = (
                self.__protocol_version.as_dict()
                if hasattr(self.__protocol_version, "as_dict")
                else self.__protocol_version
            )
        if self.__other_supported_protocol_versions is not None:
            d["otherSupportedProtocolVersions"] = [
                p.as_dict() if hasattr(p, "as_dict") else p
                for p in self.__other_supported_protocol_versions
            ]
        if self.__sdk_version is not None:
            d["sdkVersion"] = (
                self.__sdk_version.as_dict()
                if hasattr(self.__sdk_version, "as_dict")
                else self.__sdk_version
            )
        if self.__auth_token is not None:
            d["authToken"] = (
                self.__auth_token.as_dict()
                if hasattr(self.__auth_token, "as_dict")
                else self.__auth_token
            )
        return d

    def __repr__(self):
        return "<Class ConnectRequest. request_id: {}, protocol_version: {}, other_supported_protocol_versions: {}, sdk_version: {}, auth_token: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__protocol_version[:20]
                if isinstance(self.__protocol_version, bytes)
                else self.__protocol_version
            ),
            limitedRepr(
                self.__other_supported_protocol_versions[:20]
                if isinstance(self.__other_supported_protocol_versions, bytes)
                else self.__other_supported_protocol_versions
            ),
            limitedRepr(
                self.__sdk_version[:20]
                if isinstance(self.__sdk_version, bytes)
                else self.__sdk_version
            ),
            limitedRepr(
                self.__auth_token[:20]
                if isinstance(self.__auth_token, bytes)
                else self.__auth_token
            ),
        )


class ResponseStatusCode(enum.Enum):
    """
    (Internal Only) Enum defining possible response status codes from StreamManager server.
    Success: Request succeeded.
    UnknownFailure: Encountered unknown StreamManager server failure.
    Unauthorized: Client is not authorized to perform this request.
    InvalidRequest: Client request is invalid.
    RequestPayloadTooLarge: Request payload is too large.
    ResourceNotFound: The requested resource does not exist.
    ServerTimeout: Server took too long and timed out.
    ResponsePayloadTooLarge: Server response exceeded the max allowed response payload size by the protocol.
    UnsupportedConnectVersion: Server does not support the Connect version presented by the Client.
    UnexpectedOperation: Operation presented was not expected by the Server.
    UnsupportedProtocolVersion: Protocol version presented by the Client is not compatible with the Server.
    InvalidProtocolVersion: Protocol version presented by the Client is not valid.
    FailedToConnect: Client failed to connect to the Server.
    NotEnoughMessages: There is not enough messages to return.
    MessageStoreReadError: Read messages encountered an error.
    OutOfMemoryError: Server ran out of memory.
    UpdateFailed: Update operation failed.
    UpdateNotAllowed: One or more fields are not allowed to be updated.
    UnknownOperation: Client request is not recognized by the server.
    """

    Success = 0
    UnknownFailure = 1
    Unauthorized = 2
    InvalidRequest = 3
    RequestPayloadTooLarge = 4
    ResourceNotFound = 5
    ServerTimeout = 6
    ResponsePayloadTooLarge = 7
    UnsupportedConnectVersion = 8
    UnexpectedOperation = 9
    UnsupportedProtocolVersion = 10
    InvalidProtocolVersion = 11
    FailedToConnect = 12
    NotEnoughMessages = 13
    MessageStoreReadError = 14
    OutOfMemoryError = 15
    UpdateFailed = 16
    UpdateNotAllowed = 17
    UnknownOperation = 18

    @staticmethod
    def from_dict(d):
        return ResponseStatusCode(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum ResponseStatusCode. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class ConnectResponse:
    """
    Internal Only.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
        "__protocol_version",
        "__supported_protocol_versions",
        "__server_version",
        "__client_identifier",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
        "protocol_version": {"type": str, "subtype": None},
        "supported_protocol_versions": {"type": list, "subtype": str},
        "server_version": {"type": str, "subtype": None},
        "client_identifier": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": False,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
        "protocol_version": {
            "required": False,
        },
        "supported_protocol_versions": {
            "required": False,
        },
        "server_version": {
            "required": False,
        },
        "client_identifier": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
        protocol_version: str = None,
        supported_protocol_versions: List[str] = None,
        server_version: str = None,
        client_identifier: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message
        self.__protocol_version = protocol_version
        self.__supported_protocol_versions = supported_protocol_versions
        self.__server_version = server_version
        self.__client_identifier = client_identifier

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    def _get_protocol_version(self):
        return self.__protocol_version

    def _set_protocol_version(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("protocol_version must be str")

        self.__protocol_version = value

    protocol_version = property(_get_protocol_version, _set_protocol_version)

    def _get_supported_protocol_versions(self):
        return self.__supported_protocol_versions

    def _set_supported_protocol_versions(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("supported_protocol_versions must be list")
        if value is not None and not all(isinstance(i, str) for i in value):
            raise TypeError("supported_protocol_versions list values must be str")

        self.__supported_protocol_versions = value

    supported_protocol_versions = property(
        _get_supported_protocol_versions, _set_supported_protocol_versions
    )

    def _get_server_version(self):
        return self.__server_version

    def _set_server_version(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("server_version must be str")

        self.__server_version = value

    server_version = property(_get_server_version, _set_server_version)

    def _get_client_identifier(self):
        return self.__client_identifier

    def _set_client_identifier(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("client_identifier must be str")

        self.__client_identifier = value

    client_identifier = property(_get_client_identifier, _set_client_identifier)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        if "protocolVersion" in d:
            v["protocol_version"] = (
                str.from_dict(d["protocolVersion"])
                if hasattr(str, "from_dict")
                else d["protocolVersion"]
            )
        if "supportedProtocolVersions" in d:
            v["supported_protocol_versions"] = [
                str.from_dict(p) if hasattr(str, "from_dict") else p
                for p in d["supportedProtocolVersions"]
            ]
        if "serverVersion" in d:
            v["server_version"] = (
                str.from_dict(d["serverVersion"])
                if hasattr(str, "from_dict")
                else d["serverVersion"]
            )
        if "clientIdentifier" in d:
            v["client_identifier"] = (
                str.from_dict(d["clientIdentifier"])
                if hasattr(str, "from_dict")
                else d["clientIdentifier"]
            )
        return ConnectResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        if self.__protocol_version is not None:
            d["protocolVersion"] = (
                self.__protocol_version.as_dict()
                if hasattr(self.__protocol_version, "as_dict")
                else self.__protocol_version
            )
        if self.__supported_protocol_versions is not None:
            d["supportedProtocolVersions"] = [
                p.as_dict() if hasattr(p, "as_dict") else p
                for p in self.__supported_protocol_versions
            ]
        if self.__server_version is not None:
            d["serverVersion"] = (
                self.__server_version.as_dict()
                if hasattr(self.__server_version, "as_dict")
                else self.__server_version
            )
        if self.__client_identifier is not None:
            d["clientIdentifier"] = (
                self.__client_identifier.as_dict()
                if hasattr(self.__client_identifier, "as_dict")
                else self.__client_identifier
            )
        return d

    def __repr__(self):
        return "<Class ConnectResponse. request_id: {}, status: {}, error_message: {}, protocol_version: {}, supported_protocol_versions: {}, server_version: {}, client_identifier: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
            limitedRepr(
                self.__protocol_version[:20]
                if isinstance(self.__protocol_version, bytes)
                else self.__protocol_version
            ),
            limitedRepr(
                self.__supported_protocol_versions[:20]
                if isinstance(self.__supported_protocol_versions, bytes)
                else self.__supported_protocol_versions
            ),
            limitedRepr(
                self.__server_version[:20]
                if isinstance(self.__server_version, bytes)
                else self.__server_version
            ),
            limitedRepr(
                self.__client_identifier[:20]
                if isinstance(self.__client_identifier, bytes)
                else self.__client_identifier
            ),
        )


class Operation(enum.Enum):
    """
    Internal Only.
    """

    Unknown = 0
    Connect = 1
    CreateMessageStream = 2
    DeleteMessageStream = 3
    AppendMessage = 4
    ReadMessages = 5
    ConnectResponse = 6
    CreateMessageStreamResponse = 7
    DeleteMessageStreamResponse = 8
    AppendMessageResponse = 9
    ReadMessagesResponse = 10
    ListStreams = 11
    ListStreamsResponse = 12
    DescribeMessageStream = 13
    DescribeMessageStreamResponse = 14
    UpdateMessageStream = 15
    UpdateMessageStreamResponse = 16
    UnknownOperationError = 17

    @staticmethod
    def from_dict(d):
        return Operation(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum Operation. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class MessageFrame:
    """
    Internal Only.
    """

    __slots__ = [
        "__operation",
        "__payload",
    ]

    _types_map = {
        "operation": {"type": Operation, "subtype": None},
        "payload": {"type": bytes, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "operation": {
            "required": True,
        },
        "payload": {
            "required": True,
        },
    }

    def __init__(self, operation: Operation = None, payload: bytes = None):
        pass
        self.__operation = operation
        self.__payload = payload

    def _get_operation(self):
        return self.__operation

    def _set_operation(self, value):
        if not isinstance(value, Operation):
            raise TypeError("operation must be Operation")

        self.__operation = value

    operation = property(_get_operation, _set_operation)

    def _get_payload(self):
        return self.__payload

    def _set_payload(self, value):
        if not isinstance(value, bytes):
            raise TypeError("payload must be bytes")

        self.__payload = value

    payload = property(_get_payload, _set_payload)

    @staticmethod
    def from_dict(d):
        v = {}
        if "operation" in d:
            v["operation"] = (
                Operation.from_dict(d["operation"])
                if hasattr(Operation, "from_dict")
                else d["operation"]
            )
        if "payload" in d:
            v["payload"] = (
                bytes.from_dict(d["payload"])
                if hasattr(bytes, "from_dict")
                else d["payload"]
            )
        return MessageFrame(**v)

    def as_dict(self):
        d = {}
        if self.__operation is not None:
            d["operation"] = (
                self.__operation.as_dict()
                if hasattr(self.__operation, "as_dict")
                else self.__operation
            )
        if self.__payload is not None:
            d["payload"] = (
                self.__payload.as_dict()
                if hasattr(self.__payload, "as_dict")
                else self.__payload
            )
        return d

    def __repr__(self):
        return "<Class MessageFrame. operation: {}, payload: {}>".format(
            limitedRepr(
                self.__operation[:20]
                if isinstance(self.__operation, bytes)
                else self.__operation
            ),
            limitedRepr(
                self.__payload[:20]
                if isinstance(self.__payload, bytes)
                else self.__payload
            ),
        )


class Status(enum.Enum):
    """
    The status of the event.
    """

    Success = 0
    Failure = 1
    InProgress = 2
    Warning = 3
    Canceled = 4

    @staticmethod
    def from_dict(d):
        return Status(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum Status. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class StatusLevel(enum.Enum):
    """
    Defines the verbosity of status messages in a status-stream.
    """

    ERROR = 0
    WARN = 1
    INFO = 2
    DEBUG = 3
    TRACE = 4

    @staticmethod
    def from_dict(d):
        return StatusLevel(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum StatusLevel. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class S3ExportTaskDefinition:
    """
    S3 Task definition containing all the information necessary to export the data to S3. This will contain the S3 bucket and key as well as the file's URL where the data is stored.
    """

    __slots__ = [
        "__input_url",
        "__bucket",
        "__key",
        "__user_metadata",
    ]

    _types_map = {
        "input_url": {"type": str, "subtype": None},
        "bucket": {"type": str, "subtype": None},
        "key": {"type": str, "subtype": None},
        "user_metadata": {"type": dict, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "input_url": {
            "required": True,
        },
        "bucket": {
            "required": True,
            "minLength": 3,
            "maxLength": 63,
            "pattern": "(?=^.{3,63}$)(?!^(\d+\.)+\d+$)(^(([a-z0-9]|[a-z0-9][a-z0-9\-]*[a-z0-9])\.)*([a-z0-9]|[a-z0-9][a-z0-9\-]*[a-z0-9])$)",
        },
        "key": {
            "required": True,
            "minLength": 1,
            "maxLength": 1024,
            "pattern": "^([^\\\{ \}%\`\[\]\"'\>\<\~\#\^\?\|]|!\{[a-zA-Z]+:[a-zA-Z\/]+\})*$",
        },
        "user_metadata": {
            "required": False,
        },
    }

    def __init__(
        self,
        input_url: str = None,
        bucket: str = None,
        key: str = None,
        user_metadata: dict = None,
    ):
        """
        :param input_url: The URL of the file that contains the data to upload. The file should be local on the disk.
        :param bucket: The name of the S3 bucket that this file should be uploaded to.
        :param key: The key for the S3 object that this file should be uploaded to.
            The string can have placeholder expressions which are resolved at upload time. Valid expressions are strings that are valid Java DateTimeFormatter strings. See https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html
            Example: myKeyNamePrefix/!{timestamp:yyyy/MM/dd}/myKeyNameSuffix.
        :param user_metadata: User metadata. For key of a user metadata, callers should not include the internal "x-amz-meta-" prefix. Keys are case insensitive and will appear as lowercase strings on S3, even if they were originally specified with uppercase strings. Reserved key names start with "$aws-gg-" prefix.
        """
        pass
        self.__input_url = input_url
        self.__bucket = bucket
        self.__key = key
        self.__user_metadata = user_metadata

    def _get_input_url(self):
        return self.__input_url

    def _set_input_url(self, value):
        if not isinstance(value, str):
            raise TypeError("input_url must be str")

        self.__input_url = value

    input_url = property(_get_input_url, _set_input_url)
    """
    The URL of the file that contains the data to upload. The file should be local on the disk.
    """

    def _get_bucket(self):
        return self.__bucket

    def _set_bucket(self, value):
        if not isinstance(value, str):
            raise TypeError("bucket must be str")

        self.__bucket = value

    bucket = property(_get_bucket, _set_bucket)
    """
    The name of the S3 bucket that this file should be uploaded to.
    """

    def _get_key(self):
        return self.__key

    def _set_key(self, value):
        if not isinstance(value, str):
            raise TypeError("key must be str")

        self.__key = value

    key = property(_get_key, _set_key)
    """
    The key for the S3 object that this file should be uploaded to.
    The string can have placeholder expressions which are resolved at upload time. Valid expressions are strings that are valid Java DateTimeFormatter strings. See https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html
    Example: myKeyNamePrefix/!{timestamp:yyyy/MM/dd}/myKeyNameSuffix.
    """

    def _get_user_metadata(self):
        return self.__user_metadata

    def _set_user_metadata(self, value):
        if value is not None and not isinstance(value, dict):
            raise TypeError("user_metadata must be dict")

        self.__user_metadata = value

    user_metadata = property(_get_user_metadata, _set_user_metadata)
    """
    User metadata. For key of a user metadata, callers should not include the internal "x-amz-meta-" prefix. Keys are case insensitive and will appear as lowercase strings on S3, even if they were originally specified with uppercase strings. Reserved key names start with "$aws-gg-" prefix.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "inputUrl" in d:
            v["input_url"] = (
                str.from_dict(d["inputUrl"])
                if hasattr(str, "from_dict")
                else d["inputUrl"]
            )
        if "bucket" in d:
            v["bucket"] = (
                str.from_dict(d["bucket"]) if hasattr(str, "from_dict") else d["bucket"]
            )
        if "key" in d:
            v["key"] = (
                str.from_dict(d["key"]) if hasattr(str, "from_dict") else d["key"]
            )
        if "userMetadata" in d:
            v["user_metadata"] = (
                dict.from_dict(d["userMetadata"])
                if hasattr(dict, "from_dict")
                else d["userMetadata"]
            )
        return S3ExportTaskDefinition(**v)

    def as_dict(self):
        d = {}
        if self.__input_url is not None:
            d["inputUrl"] = (
                self.__input_url.as_dict()
                if hasattr(self.__input_url, "as_dict")
                else self.__input_url
            )
        if self.__bucket is not None:
            d["bucket"] = (
                self.__bucket.as_dict()
                if hasattr(self.__bucket, "as_dict")
                else self.__bucket
            )
        if self.__key is not None:
            d["key"] = (
                self.__key.as_dict() if hasattr(self.__key, "as_dict") else self.__key
            )
        if self.__user_metadata is not None:
            d["userMetadata"] = (
                self.__user_metadata.as_dict()
                if hasattr(self.__user_metadata, "as_dict")
                else self.__user_metadata
            )
        return d

    def __repr__(self):
        return "<Class S3ExportTaskDefinition. input_url: {}, bucket: {}, key: {}, user_metadata: {}>".format(
            limitedRepr(
                self.__input_url[:20]
                if isinstance(self.__input_url, bytes)
                else self.__input_url
            ),
            limitedRepr(
                self.__bucket[:20]
                if isinstance(self.__bucket, bytes)
                else self.__bucket
            ),
            limitedRepr(
                self.__key[:20] if isinstance(self.__key, bytes) else self.__key
            ),
            limitedRepr(
                self.__user_metadata[:20]
                if isinstance(self.__user_metadata, bytes)
                else self.__user_metadata
            ),
        )


class StatusContext:
    """
    Context associated with a status message. Describes which stream, export config, message, the status is associated with.
    """

    __slots__ = [
        "__s3_export_task_definition",
        "__export_identifier",
        "__stream_name",
        "__sequence_number",
    ]

    _types_map = {
        "s3_export_task_definition": {"type": S3ExportTaskDefinition, "subtype": None},
        "export_identifier": {"type": str, "subtype": None},
        "stream_name": {"type": str, "subtype": None},
        "sequence_number": {"type": int, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "s3_export_task_definition": {
            "required": False,
        },
        "export_identifier": {
            "required": False,
        },
        "stream_name": {
            "required": False,
        },
        "sequence_number": {
            "required": False,
        },
    }

    def __init__(
        self,
        s3_export_task_definition: S3ExportTaskDefinition = None,
        export_identifier: str = None,
        stream_name: str = None,
        sequence_number: int = None,
    ):
        """
        :param s3_export_task_definition: The task definition of an S3 upload task if the status is associated with it, ie, if the eventType = S3Task.
        :param export_identifier: The export identifier the status is associated with.
        :param stream_name: The name of the stream the status is associated with.
        :param sequence_number: The sequence number of the message the status is associated with.
        """
        pass
        self.__s3_export_task_definition = s3_export_task_definition
        self.__export_identifier = export_identifier
        self.__stream_name = stream_name
        self.__sequence_number = sequence_number

    def _get_s3_export_task_definition(self):
        return self.__s3_export_task_definition

    def _set_s3_export_task_definition(self, value):
        if value is not None and not isinstance(value, S3ExportTaskDefinition):
            raise TypeError("s3_export_task_definition must be S3ExportTaskDefinition")

        self.__s3_export_task_definition = value

    s3_export_task_definition = property(
        _get_s3_export_task_definition, _set_s3_export_task_definition
    )
    """
    The task definition of an S3 upload task if the status is associated with it, ie, if the eventType = S3Task.
    """

    def _get_export_identifier(self):
        return self.__export_identifier

    def _set_export_identifier(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("export_identifier must be str")

        self.__export_identifier = value

    export_identifier = property(_get_export_identifier, _set_export_identifier)
    """
    The export identifier the status is associated with.
    """

    def _get_stream_name(self):
        return self.__stream_name

    def _set_stream_name(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("stream_name must be str")

        self.__stream_name = value

    stream_name = property(_get_stream_name, _set_stream_name)
    """
    The name of the stream the status is associated with.
    """

    def _get_sequence_number(self):
        return self.__sequence_number

    def _set_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("sequence_number must be int")

        self.__sequence_number = value

    sequence_number = property(_get_sequence_number, _set_sequence_number)
    """
    The sequence number of the message the status is associated with.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "s3ExportTaskDefinition" in d:
            v["s3_export_task_definition"] = (
                S3ExportTaskDefinition.from_dict(d["s3ExportTaskDefinition"])
                if hasattr(S3ExportTaskDefinition, "from_dict")
                else d["s3ExportTaskDefinition"]
            )
        if "exportIdentifier" in d:
            v["export_identifier"] = (
                str.from_dict(d["exportIdentifier"])
                if hasattr(str, "from_dict")
                else d["exportIdentifier"]
            )
        if "streamName" in d:
            v["stream_name"] = (
                str.from_dict(d["streamName"])
                if hasattr(str, "from_dict")
                else d["streamName"]
            )
        if "sequenceNumber" in d:
            v["sequence_number"] = (
                int.from_dict(d["sequenceNumber"])
                if hasattr(int, "from_dict")
                else d["sequenceNumber"]
            )
        return StatusContext(**v)

    def as_dict(self):
        d = {}
        if self.__s3_export_task_definition is not None:
            d["s3ExportTaskDefinition"] = (
                self.__s3_export_task_definition.as_dict()
                if hasattr(self.__s3_export_task_definition, "as_dict")
                else self.__s3_export_task_definition
            )
        if self.__export_identifier is not None:
            d["exportIdentifier"] = (
                self.__export_identifier.as_dict()
                if hasattr(self.__export_identifier, "as_dict")
                else self.__export_identifier
            )
        if self.__stream_name is not None:
            d["streamName"] = (
                self.__stream_name.as_dict()
                if hasattr(self.__stream_name, "as_dict")
                else self.__stream_name
            )
        if self.__sequence_number is not None:
            d["sequenceNumber"] = (
                self.__sequence_number.as_dict()
                if hasattr(self.__sequence_number, "as_dict")
                else self.__sequence_number
            )
        return d

    def __repr__(self):
        return "<Class StatusContext. s3_export_task_definition: {}, export_identifier: {}, stream_name: {}, sequence_number: {}>".format(
            limitedRepr(
                self.__s3_export_task_definition[:20]
                if isinstance(self.__s3_export_task_definition, bytes)
                else self.__s3_export_task_definition
            ),
            limitedRepr(
                self.__export_identifier[:20]
                if isinstance(self.__export_identifier, bytes)
                else self.__export_identifier
            ),
            limitedRepr(
                self.__stream_name[:20]
                if isinstance(self.__stream_name, bytes)
                else self.__stream_name
            ),
            limitedRepr(
                self.__sequence_number[:20]
                if isinstance(self.__sequence_number, bytes)
                else self.__sequence_number
            ),
        )


class EventType(enum.Enum):
    """
    The type of event, which determines how to interpret the status payload.
    """

    S3Task = 0

    @staticmethod
    def from_dict(d):
        return EventType(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum EventType. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class StatusMessage:
    """
    Status object appended to a status-stream.
    """

    __slots__ = [
        "__event_type",
        "__status_level",
        "__status",
        "__status_context",
        "__message",
        "__timestamp_epoch_ms",
    ]

    _types_map = {
        "event_type": {"type": EventType, "subtype": None},
        "status_level": {"type": StatusLevel, "subtype": None},
        "status": {"type": Status, "subtype": None},
        "status_context": {"type": StatusContext, "subtype": None},
        "message": {"type": str, "subtype": None},
        "timestamp_epoch_ms": {"type": int, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "event_type": {
            "required": True,
        },
        "status_level": {
            "required": False,
        },
        "status": {
            "required": True,
        },
        "status_context": {
            "required": False,
        },
        "message": {
            "required": False,
        },
        "timestamp_epoch_ms": {
            "required": False,
        },
    }

    def __init__(
        self,
        event_type: EventType = None,
        status_level: StatusLevel = None,
        status: Status = None,
        status_context: StatusContext = None,
        message: str = None,
        timestamp_epoch_ms: int = None,
    ):
        """
        :param message: String describing the status message.
        :param timestamp_epoch_ms: The time this status was added to the status-stream (in milliseconds since epoch).
        """
        pass
        self.__event_type = event_type
        self.__status_level = status_level
        self.__status = status
        self.__status_context = status_context
        self.__message = message
        self.__timestamp_epoch_ms = timestamp_epoch_ms

    def _get_event_type(self):
        return self.__event_type

    def _set_event_type(self, value):
        if not isinstance(value, EventType):
            raise TypeError("event_type must be EventType")

        self.__event_type = value

    event_type = property(_get_event_type, _set_event_type)

    def _get_status_level(self):
        return self.__status_level

    def _set_status_level(self, value):
        if value is not None and not isinstance(value, StatusLevel):
            raise TypeError("status_level must be StatusLevel")

        self.__status_level = value

    status_level = property(_get_status_level, _set_status_level)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, Status):
            raise TypeError("status must be Status")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_status_context(self):
        return self.__status_context

    def _set_status_context(self, value):
        if value is not None and not isinstance(value, StatusContext):
            raise TypeError("status_context must be StatusContext")

        self.__status_context = value

    status_context = property(_get_status_context, _set_status_context)

    def _get_message(self):
        return self.__message

    def _set_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("message must be str")

        self.__message = value

    message = property(_get_message, _set_message)
    """
    String describing the status message.
    """

    def _get_timestamp_epoch_ms(self):
        return self.__timestamp_epoch_ms

    def _set_timestamp_epoch_ms(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("timestamp_epoch_ms must be int")

        self.__timestamp_epoch_ms = value

    timestamp_epoch_ms = property(_get_timestamp_epoch_ms, _set_timestamp_epoch_ms)
    """
    The time this status was added to the status-stream (in milliseconds since epoch).
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "eventType" in d:
            v["event_type"] = (
                EventType.from_dict(d["eventType"])
                if hasattr(EventType, "from_dict")
                else d["eventType"]
            )
        if "statusLevel" in d:
            v["status_level"] = (
                StatusLevel.from_dict(d["statusLevel"])
                if hasattr(StatusLevel, "from_dict")
                else d["statusLevel"]
            )
        if "status" in d:
            v["status"] = (
                Status.from_dict(d["status"])
                if hasattr(Status, "from_dict")
                else d["status"]
            )
        if "statusContext" in d:
            v["status_context"] = (
                StatusContext.from_dict(d["statusContext"])
                if hasattr(StatusContext, "from_dict")
                else d["statusContext"]
            )
        if "message" in d:
            v["message"] = (
                str.from_dict(d["message"])
                if hasattr(str, "from_dict")
                else d["message"]
            )
        if "timestampEpochMs" in d:
            v["timestamp_epoch_ms"] = (
                int.from_dict(d["timestampEpochMs"])
                if hasattr(int, "from_dict")
                else d["timestampEpochMs"]
            )
        return StatusMessage(**v)

    def as_dict(self):
        d = {}
        if self.__event_type is not None:
            d["eventType"] = (
                self.__event_type.as_dict()
                if hasattr(self.__event_type, "as_dict")
                else self.__event_type
            )
        if self.__status_level is not None:
            d["statusLevel"] = (
                self.__status_level.as_dict()
                if hasattr(self.__status_level, "as_dict")
                else self.__status_level
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__status_context is not None:
            d["statusContext"] = (
                self.__status_context.as_dict()
                if hasattr(self.__status_context, "as_dict")
                else self.__status_context
            )
        if self.__message is not None:
            d["message"] = (
                self.__message.as_dict()
                if hasattr(self.__message, "as_dict")
                else self.__message
            )
        if self.__timestamp_epoch_ms is not None:
            d["timestampEpochMs"] = (
                self.__timestamp_epoch_ms.as_dict()
                if hasattr(self.__timestamp_epoch_ms, "as_dict")
                else self.__timestamp_epoch_ms
            )
        return d

    def __repr__(self):
        return "<Class StatusMessage. event_type: {}, status_level: {}, status: {}, status_context: {}, message: {}, timestamp_epoch_ms: {}>".format(
            limitedRepr(
                self.__event_type[:20]
                if isinstance(self.__event_type, bytes)
                else self.__event_type
            ),
            limitedRepr(
                self.__status_level[:20]
                if isinstance(self.__status_level, bytes)
                else self.__status_level
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__status_context[:20]
                if isinstance(self.__status_context, bytes)
                else self.__status_context
            ),
            limitedRepr(
                self.__message[:20]
                if isinstance(self.__message, bytes)
                else self.__message
            ),
            limitedRepr(
                self.__timestamp_epoch_ms[:20]
                if isinstance(self.__timestamp_epoch_ms, bytes)
                else self.__timestamp_epoch_ms
            ),
        )


class TraceableRequest:
    """
    (Internal Only) TraceableRequest that contains only requestId.
    """

    __slots__ = [
        "__request_id",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
    }

    def __init__(self, request_id: str = None):
        pass
        self.__request_id = request_id

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        return TraceableRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        return d

    def __repr__(self):
        return "<Class TraceableRequest. request_id: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            )
        )


class UnknownOperationError:
    """
    (Internal Only) Response for UnknownOperationError.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        return UnknownOperationError(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        return d

    def __repr__(self):
        return "<Class UnknownOperationError. request_id: {}, status: {}, error_message: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
        )


class KinesisConfig:
    """
    Configuration object for Kinesis data streams export destination.
    """

    __slots__ = [
        "__identifier",
        "__kinesis_stream_name",
        "__batch_size",
        "__batch_interval_millis",
        "__priority",
        "__start_sequence_number",
        "__disabled",
    ]

    _types_map = {
        "identifier": {"type": str, "subtype": None},
        "kinesis_stream_name": {"type": str, "subtype": None},
        "batch_size": {"type": int, "subtype": None},
        "batch_interval_millis": {"type": int, "subtype": None},
        "priority": {"type": int, "subtype": None},
        "start_sequence_number": {"type": int, "subtype": None},
        "disabled": {"type": bool, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "identifier": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "kinesis_stream_name": {
            "required": True,
            "minLength": 1,
        },
        "batch_size": {
            "required": False,
            "maximum": 500,
            "minimum": 1,
        },
        "batch_interval_millis": {
            "required": False,
            "maximum": 9223372036854,
            "minimum": 60000,
        },
        "priority": {
            "required": False,
            "maximum": 10,
            "minimum": 1,
        },
        "start_sequence_number": {
            "required": False,
            "maximum": 9223372036854775807,
            "minimum": 0,
        },
        "disabled": {
            "required": False,
        },
    }

    def __init__(
        self,
        identifier: str = None,
        kinesis_stream_name: str = None,
        batch_size: int = None,
        batch_interval_millis: int = None,
        priority: int = None,
        start_sequence_number: int = None,
        disabled: bool = None,
    ):
        """
        :param identifier: A unique identifier to identify this individual upload stream.
            Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
        :param kinesis_stream_name: The name of the Kinesis data stream that this exporter should upload to.
        :param batch_size: The maximum size of a batch to send to Kinesis. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 500.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The batch size must be between 1 and 500.
        :param batch_interval_millis: The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
        :param priority: Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
        :param start_sequence_number: The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
        :param disabled: Enable or disable this export. Default is false.
        """
        pass
        self.__identifier = identifier
        self.__kinesis_stream_name = kinesis_stream_name
        self.__batch_size = batch_size
        self.__batch_interval_millis = batch_interval_millis
        self.__priority = priority
        self.__start_sequence_number = start_sequence_number
        self.__disabled = disabled

    def _get_identifier(self):
        return self.__identifier

    def _set_identifier(self, value):
        if not isinstance(value, str):
            raise TypeError("identifier must be str")

        self.__identifier = value

    identifier = property(_get_identifier, _set_identifier)
    """
    A unique identifier to identify this individual upload stream.
    Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
    """

    def _get_kinesis_stream_name(self):
        return self.__kinesis_stream_name

    def _set_kinesis_stream_name(self, value):
        if not isinstance(value, str):
            raise TypeError("kinesis_stream_name must be str")

        self.__kinesis_stream_name = value

    kinesis_stream_name = property(_get_kinesis_stream_name, _set_kinesis_stream_name)
    """
    The name of the Kinesis data stream that this exporter should upload to.
    """

    def _get_batch_size(self):
        return self.__batch_size

    def _set_batch_size(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_size must be int")

        self.__batch_size = value

    batch_size = property(_get_batch_size, _set_batch_size)
    """
    The maximum size of a batch to send to Kinesis. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 500.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The batch size must be between 1 and 500.
    """

    def _get_batch_interval_millis(self):
        return self.__batch_interval_millis

    def _set_batch_interval_millis(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_interval_millis must be int")

        self.__batch_interval_millis = value

    batch_interval_millis = property(
        _get_batch_interval_millis, _set_batch_interval_millis
    )
    """
    The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
    """

    def _get_priority(self):
        return self.__priority

    def _set_priority(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("priority must be int")

        self.__priority = value

    priority = property(_get_priority, _set_priority)
    """
    Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
    """

    def _get_start_sequence_number(self):
        return self.__start_sequence_number

    def _set_start_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("start_sequence_number must be int")

        self.__start_sequence_number = value

    start_sequence_number = property(
        _get_start_sequence_number, _set_start_sequence_number
    )
    """
    The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
    """

    def _get_disabled(self):
        return self.__disabled

    def _set_disabled(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("disabled must be bool")

        self.__disabled = value

    disabled = property(_get_disabled, _set_disabled)
    """
    Enable or disable this export. Default is false.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "identifier" in d:
            v["identifier"] = (
                str.from_dict(d["identifier"])
                if hasattr(str, "from_dict")
                else d["identifier"]
            )
        if "kinesisStreamName" in d:
            v["kinesis_stream_name"] = (
                str.from_dict(d["kinesisStreamName"])
                if hasattr(str, "from_dict")
                else d["kinesisStreamName"]
            )
        if "batchSize" in d:
            v["batch_size"] = (
                int.from_dict(d["batchSize"])
                if hasattr(int, "from_dict")
                else d["batchSize"]
            )
        if "batchIntervalMillis" in d:
            v["batch_interval_millis"] = (
                int.from_dict(d["batchIntervalMillis"])
                if hasattr(int, "from_dict")
                else d["batchIntervalMillis"]
            )
        if "priority" in d:
            v["priority"] = (
                int.from_dict(d["priority"])
                if hasattr(int, "from_dict")
                else d["priority"]
            )
        if "startSequenceNumber" in d:
            v["start_sequence_number"] = (
                int.from_dict(d["startSequenceNumber"])
                if hasattr(int, "from_dict")
                else d["startSequenceNumber"]
            )
        if "disabled" in d:
            v["disabled"] = (
                bool.from_dict(d["disabled"])
                if hasattr(bool, "from_dict")
                else d["disabled"]
            )
        return KinesisConfig(**v)

    def as_dict(self):
        d = {}
        if self.__identifier is not None:
            d["identifier"] = (
                self.__identifier.as_dict()
                if hasattr(self.__identifier, "as_dict")
                else self.__identifier
            )
        if self.__kinesis_stream_name is not None:
            d["kinesisStreamName"] = (
                self.__kinesis_stream_name.as_dict()
                if hasattr(self.__kinesis_stream_name, "as_dict")
                else self.__kinesis_stream_name
            )
        if self.__batch_size is not None:
            d["batchSize"] = (
                self.__batch_size.as_dict()
                if hasattr(self.__batch_size, "as_dict")
                else self.__batch_size
            )
        if self.__batch_interval_millis is not None:
            d["batchIntervalMillis"] = (
                self.__batch_interval_millis.as_dict()
                if hasattr(self.__batch_interval_millis, "as_dict")
                else self.__batch_interval_millis
            )
        if self.__priority is not None:
            d["priority"] = (
                self.__priority.as_dict()
                if hasattr(self.__priority, "as_dict")
                else self.__priority
            )
        if self.__start_sequence_number is not None:
            d["startSequenceNumber"] = (
                self.__start_sequence_number.as_dict()
                if hasattr(self.__start_sequence_number, "as_dict")
                else self.__start_sequence_number
            )
        if self.__disabled is not None:
            d["disabled"] = (
                self.__disabled.as_dict()
                if hasattr(self.__disabled, "as_dict")
                else self.__disabled
            )
        return d

    def __repr__(self):
        return "<Class KinesisConfig. identifier: {}, kinesis_stream_name: {}, batch_size: {}, batch_interval_millis: {}, priority: {}, start_sequence_number: {}, disabled: {}>".format(
            limitedRepr(
                self.__identifier[:20]
                if isinstance(self.__identifier, bytes)
                else self.__identifier
            ),
            limitedRepr(
                self.__kinesis_stream_name[:20]
                if isinstance(self.__kinesis_stream_name, bytes)
                else self.__kinesis_stream_name
            ),
            limitedRepr(
                self.__batch_size[:20]
                if isinstance(self.__batch_size, bytes)
                else self.__batch_size
            ),
            limitedRepr(
                self.__batch_interval_millis[:20]
                if isinstance(self.__batch_interval_millis, bytes)
                else self.__batch_interval_millis
            ),
            limitedRepr(
                self.__priority[:20]
                if isinstance(self.__priority, bytes)
                else self.__priority
            ),
            limitedRepr(
                self.__start_sequence_number[:20]
                if isinstance(self.__start_sequence_number, bytes)
                else self.__start_sequence_number
            ),
            limitedRepr(
                self.__disabled[:20]
                if isinstance(self.__disabled, bytes)
                else self.__disabled
            ),
        )


class IoTSiteWiseConfig:
    """
    Configuration object for IotSiteWise data streams export destination. Minimum version requirements: StreamManager server version 1.1 (or AWS IoT Greengrass Core 1.11.0)
    """

    __slots__ = [
        "__identifier",
        "__batch_size",
        "__batch_interval_millis",
        "__priority",
        "__start_sequence_number",
        "__disabled",
    ]

    _types_map = {
        "identifier": {"type": str, "subtype": None},
        "batch_size": {"type": int, "subtype": None},
        "batch_interval_millis": {"type": int, "subtype": None},
        "priority": {"type": int, "subtype": None},
        "start_sequence_number": {"type": int, "subtype": None},
        "disabled": {"type": bool, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "identifier": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "batch_size": {
            "required": False,
            "maximum": 10,
            "minimum": 1,
        },
        "batch_interval_millis": {
            "required": False,
            "maximum": 9223372036854,
            "minimum": 60000,
        },
        "priority": {
            "required": False,
            "maximum": 10,
            "minimum": 1,
        },
        "start_sequence_number": {
            "required": False,
            "maximum": 9223372036854775807,
            "minimum": 0,
        },
        "disabled": {
            "required": False,
        },
    }

    def __init__(
        self,
        identifier: str = None,
        batch_size: int = None,
        batch_interval_millis: int = None,
        priority: int = None,
        start_sequence_number: int = None,
        disabled: bool = None,
    ):
        """
        :param identifier: A unique identifier to identify this individual upload stream.
            Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
        :param batch_size: The maximum size of a batch to send to the destination. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 10.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The minimum batch size is 1 and the maximum is 10.
        :param batch_interval_millis: The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
        :param priority: Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
        :param start_sequence_number: The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
        :param disabled: Enable or disable this export. Default is false.
        """
        pass
        self.__identifier = identifier
        self.__batch_size = batch_size
        self.__batch_interval_millis = batch_interval_millis
        self.__priority = priority
        self.__start_sequence_number = start_sequence_number
        self.__disabled = disabled

    def _get_identifier(self):
        return self.__identifier

    def _set_identifier(self, value):
        if not isinstance(value, str):
            raise TypeError("identifier must be str")

        self.__identifier = value

    identifier = property(_get_identifier, _set_identifier)
    """
    A unique identifier to identify this individual upload stream.
    Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
    """

    def _get_batch_size(self):
        return self.__batch_size

    def _set_batch_size(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_size must be int")

        self.__batch_size = value

    batch_size = property(_get_batch_size, _set_batch_size)
    """
    The maximum size of a batch to send to the destination. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 10.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The minimum batch size is 1 and the maximum is 10.
    """

    def _get_batch_interval_millis(self):
        return self.__batch_interval_millis

    def _set_batch_interval_millis(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_interval_millis must be int")

        self.__batch_interval_millis = value

    batch_interval_millis = property(
        _get_batch_interval_millis, _set_batch_interval_millis
    )
    """
    The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
    """

    def _get_priority(self):
        return self.__priority

    def _set_priority(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("priority must be int")

        self.__priority = value

    priority = property(_get_priority, _set_priority)
    """
    Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
    """

    def _get_start_sequence_number(self):
        return self.__start_sequence_number

    def _set_start_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("start_sequence_number must be int")

        self.__start_sequence_number = value

    start_sequence_number = property(
        _get_start_sequence_number, _set_start_sequence_number
    )
    """
    The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
    """

    def _get_disabled(self):
        return self.__disabled

    def _set_disabled(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("disabled must be bool")

        self.__disabled = value

    disabled = property(_get_disabled, _set_disabled)
    """
    Enable or disable this export. Default is false.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "identifier" in d:
            v["identifier"] = (
                str.from_dict(d["identifier"])
                if hasattr(str, "from_dict")
                else d["identifier"]
            )
        if "batchSize" in d:
            v["batch_size"] = (
                int.from_dict(d["batchSize"])
                if hasattr(int, "from_dict")
                else d["batchSize"]
            )
        if "batchIntervalMillis" in d:
            v["batch_interval_millis"] = (
                int.from_dict(d["batchIntervalMillis"])
                if hasattr(int, "from_dict")
                else d["batchIntervalMillis"]
            )
        if "priority" in d:
            v["priority"] = (
                int.from_dict(d["priority"])
                if hasattr(int, "from_dict")
                else d["priority"]
            )
        if "startSequenceNumber" in d:
            v["start_sequence_number"] = (
                int.from_dict(d["startSequenceNumber"])
                if hasattr(int, "from_dict")
                else d["startSequenceNumber"]
            )
        if "disabled" in d:
            v["disabled"] = (
                bool.from_dict(d["disabled"])
                if hasattr(bool, "from_dict")
                else d["disabled"]
            )
        return IoTSiteWiseConfig(**v)

    def as_dict(self):
        d = {}
        if self.__identifier is not None:
            d["identifier"] = (
                self.__identifier.as_dict()
                if hasattr(self.__identifier, "as_dict")
                else self.__identifier
            )
        if self.__batch_size is not None:
            d["batchSize"] = (
                self.__batch_size.as_dict()
                if hasattr(self.__batch_size, "as_dict")
                else self.__batch_size
            )
        if self.__batch_interval_millis is not None:
            d["batchIntervalMillis"] = (
                self.__batch_interval_millis.as_dict()
                if hasattr(self.__batch_interval_millis, "as_dict")
                else self.__batch_interval_millis
            )
        if self.__priority is not None:
            d["priority"] = (
                self.__priority.as_dict()
                if hasattr(self.__priority, "as_dict")
                else self.__priority
            )
        if self.__start_sequence_number is not None:
            d["startSequenceNumber"] = (
                self.__start_sequence_number.as_dict()
                if hasattr(self.__start_sequence_number, "as_dict")
                else self.__start_sequence_number
            )
        if self.__disabled is not None:
            d["disabled"] = (
                self.__disabled.as_dict()
                if hasattr(self.__disabled, "as_dict")
                else self.__disabled
            )
        return d

    def __repr__(self):
        return "<Class IoTSiteWiseConfig. identifier: {}, batch_size: {}, batch_interval_millis: {}, priority: {}, start_sequence_number: {}, disabled: {}>".format(
            limitedRepr(
                self.__identifier[:20]
                if isinstance(self.__identifier, bytes)
                else self.__identifier
            ),
            limitedRepr(
                self.__batch_size[:20]
                if isinstance(self.__batch_size, bytes)
                else self.__batch_size
            ),
            limitedRepr(
                self.__batch_interval_millis[:20]
                if isinstance(self.__batch_interval_millis, bytes)
                else self.__batch_interval_millis
            ),
            limitedRepr(
                self.__priority[:20]
                if isinstance(self.__priority, bytes)
                else self.__priority
            ),
            limitedRepr(
                self.__start_sequence_number[:20]
                if isinstance(self.__start_sequence_number, bytes)
                else self.__start_sequence_number
            ),
            limitedRepr(
                self.__disabled[:20]
                if isinstance(self.__disabled, bytes)
                else self.__disabled
            ),
        )


class ExportFormat(enum.Enum):
    """
    ExportFormat is used to define how messages are batched and formatted in the export payload.
    RAW_NOT_BATCHED: Each message in a batch will be sent as an individual HTTP POST with the payload as the body (even if batchSize is set).
    JSON_BATCHED: Each batch of messages will be sent as a JSON list of Message objects as the body.
    """

    RAW_NOT_BATCHED = 0
    JSON_BATCHED = 1

    @staticmethod
    def from_dict(d):
        return ExportFormat(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum ExportFormat. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class HTTPConfig:
    """
    This export destination is not supported! The interface may change at any time without notice and should not be relied on for any production use.
    There are no guarantees around its correctness.
    This configures an HTTP endpoint which sends a POST request to the provided URI. Each request contains a single message in the body of the request.
    """

    __slots__ = [
        "__identifier",
        "__uri",
        "__batch_size",
        "__batch_interval_millis",
        "__priority",
        "__start_sequence_number",
        "__disabled",
        "__export_format",
    ]

    _types_map = {
        "identifier": {"type": str, "subtype": None},
        "uri": {"type": str, "subtype": None},
        "batch_size": {"type": int, "subtype": None},
        "batch_interval_millis": {"type": int, "subtype": None},
        "priority": {"type": int, "subtype": None},
        "start_sequence_number": {"type": int, "subtype": None},
        "disabled": {"type": bool, "subtype": None},
        "export_format": {"type": ExportFormat, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "identifier": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "uri": {
            "required": True,
            "minLength": 1,
        },
        "batch_size": {
            "required": False,
            "maximum": 500,
            "minimum": 1,
        },
        "batch_interval_millis": {
            "required": False,
            "maximum": 9223372036854,
            "minimum": 60000,
        },
        "priority": {
            "required": False,
            "maximum": 10,
            "minimum": 1,
        },
        "start_sequence_number": {
            "required": False,
            "maximum": 9223372036854775807,
            "minimum": 0,
        },
        "disabled": {
            "required": False,
        },
        "export_format": {
            "required": False,
        },
    }

    def __init__(
        self,
        identifier: str = None,
        uri: str = None,
        batch_size: int = None,
        batch_interval_millis: int = None,
        priority: int = None,
        start_sequence_number: int = None,
        disabled: bool = None,
        export_format: ExportFormat = None,
    ):
        """
        :param identifier: A unique identifier to identify this individual upload stream.
            Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
        :param uri: URL for HTTP endpoint which should receive the POST requests for export.
        :param batch_size: The maximum size of a batch to send to the destination. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 500.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The minimum batch size is 1 and the maximum is 500.
        :param batch_interval_millis: The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
        :param priority: Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
        :param start_sequence_number: The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
        :param disabled: Enable or disable this export. Default is false.
        :param export_format: Defines how messages are batched and formatted in the export payload.
        """
        pass
        self.__identifier = identifier
        self.__uri = uri
        self.__batch_size = batch_size
        self.__batch_interval_millis = batch_interval_millis
        self.__priority = priority
        self.__start_sequence_number = start_sequence_number
        self.__disabled = disabled
        self.__export_format = export_format

    def _get_identifier(self):
        return self.__identifier

    def _set_identifier(self, value):
        if not isinstance(value, str):
            raise TypeError("identifier must be str")

        self.__identifier = value

    identifier = property(_get_identifier, _set_identifier)
    """
    A unique identifier to identify this individual upload stream.
    Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
    """

    def _get_uri(self):
        return self.__uri

    def _set_uri(self, value):
        if not isinstance(value, str):
            raise TypeError("uri must be str")

        self.__uri = value

    uri = property(_get_uri, _set_uri)
    """
    URL for HTTP endpoint which should receive the POST requests for export.
    """

    def _get_batch_size(self):
        return self.__batch_size

    def _set_batch_size(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_size must be int")

        self.__batch_size = value

    batch_size = property(_get_batch_size, _set_batch_size)
    """
    The maximum size of a batch to send to the destination. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 500.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The minimum batch size is 1 and the maximum is 500.
    """

    def _get_batch_interval_millis(self):
        return self.__batch_interval_millis

    def _set_batch_interval_millis(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_interval_millis must be int")

        self.__batch_interval_millis = value

    batch_interval_millis = property(
        _get_batch_interval_millis, _set_batch_interval_millis
    )
    """
    The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
    """

    def _get_priority(self):
        return self.__priority

    def _set_priority(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("priority must be int")

        self.__priority = value

    priority = property(_get_priority, _set_priority)
    """
    Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
    """

    def _get_start_sequence_number(self):
        return self.__start_sequence_number

    def _set_start_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("start_sequence_number must be int")

        self.__start_sequence_number = value

    start_sequence_number = property(
        _get_start_sequence_number, _set_start_sequence_number
    )
    """
    The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
    """

    def _get_disabled(self):
        return self.__disabled

    def _set_disabled(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("disabled must be bool")

        self.__disabled = value

    disabled = property(_get_disabled, _set_disabled)
    """
    Enable or disable this export. Default is false.
    """

    def _get_export_format(self):
        return self.__export_format

    def _set_export_format(self, value):
        if value is not None and not isinstance(value, ExportFormat):
            raise TypeError("export_format must be ExportFormat")

        self.__export_format = value

    export_format = property(_get_export_format, _set_export_format)
    """
    Defines how messages are batched and formatted in the export payload.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "identifier" in d:
            v["identifier"] = (
                str.from_dict(d["identifier"])
                if hasattr(str, "from_dict")
                else d["identifier"]
            )
        if "uri" in d:
            v["uri"] = (
                str.from_dict(d["uri"]) if hasattr(str, "from_dict") else d["uri"]
            )
        if "batchSize" in d:
            v["batch_size"] = (
                int.from_dict(d["batchSize"])
                if hasattr(int, "from_dict")
                else d["batchSize"]
            )
        if "batchIntervalMillis" in d:
            v["batch_interval_millis"] = (
                int.from_dict(d["batchIntervalMillis"])
                if hasattr(int, "from_dict")
                else d["batchIntervalMillis"]
            )
        if "priority" in d:
            v["priority"] = (
                int.from_dict(d["priority"])
                if hasattr(int, "from_dict")
                else d["priority"]
            )
        if "startSequenceNumber" in d:
            v["start_sequence_number"] = (
                int.from_dict(d["startSequenceNumber"])
                if hasattr(int, "from_dict")
                else d["startSequenceNumber"]
            )
        if "disabled" in d:
            v["disabled"] = (
                bool.from_dict(d["disabled"])
                if hasattr(bool, "from_dict")
                else d["disabled"]
            )
        if "exportFormat" in d:
            v["export_format"] = (
                ExportFormat.from_dict(d["exportFormat"])
                if hasattr(ExportFormat, "from_dict")
                else d["exportFormat"]
            )
        return HTTPConfig(**v)

    def as_dict(self):
        d = {}
        if self.__identifier is not None:
            d["identifier"] = (
                self.__identifier.as_dict()
                if hasattr(self.__identifier, "as_dict")
                else self.__identifier
            )
        if self.__uri is not None:
            d["uri"] = (
                self.__uri.as_dict() if hasattr(self.__uri, "as_dict") else self.__uri
            )
        if self.__batch_size is not None:
            d["batchSize"] = (
                self.__batch_size.as_dict()
                if hasattr(self.__batch_size, "as_dict")
                else self.__batch_size
            )
        if self.__batch_interval_millis is not None:
            d["batchIntervalMillis"] = (
                self.__batch_interval_millis.as_dict()
                if hasattr(self.__batch_interval_millis, "as_dict")
                else self.__batch_interval_millis
            )
        if self.__priority is not None:
            d["priority"] = (
                self.__priority.as_dict()
                if hasattr(self.__priority, "as_dict")
                else self.__priority
            )
        if self.__start_sequence_number is not None:
            d["startSequenceNumber"] = (
                self.__start_sequence_number.as_dict()
                if hasattr(self.__start_sequence_number, "as_dict")
                else self.__start_sequence_number
            )
        if self.__disabled is not None:
            d["disabled"] = (
                self.__disabled.as_dict()
                if hasattr(self.__disabled, "as_dict")
                else self.__disabled
            )
        if self.__export_format is not None:
            d["exportFormat"] = (
                self.__export_format.as_dict()
                if hasattr(self.__export_format, "as_dict")
                else self.__export_format
            )
        return d

    def __repr__(self):
        return "<Class HTTPConfig. identifier: {}, uri: {}, batch_size: {}, batch_interval_millis: {}, priority: {}, start_sequence_number: {}, disabled: {}, export_format: {}>".format(
            limitedRepr(
                self.__identifier[:20]
                if isinstance(self.__identifier, bytes)
                else self.__identifier
            ),
            limitedRepr(
                self.__uri[:20] if isinstance(self.__uri, bytes) else self.__uri
            ),
            limitedRepr(
                self.__batch_size[:20]
                if isinstance(self.__batch_size, bytes)
                else self.__batch_size
            ),
            limitedRepr(
                self.__batch_interval_millis[:20]
                if isinstance(self.__batch_interval_millis, bytes)
                else self.__batch_interval_millis
            ),
            limitedRepr(
                self.__priority[:20]
                if isinstance(self.__priority, bytes)
                else self.__priority
            ),
            limitedRepr(
                self.__start_sequence_number[:20]
                if isinstance(self.__start_sequence_number, bytes)
                else self.__start_sequence_number
            ),
            limitedRepr(
                self.__disabled[:20]
                if isinstance(self.__disabled, bytes)
                else self.__disabled
            ),
            limitedRepr(
                self.__export_format[:20]
                if isinstance(self.__export_format, bytes)
                else self.__export_format
            ),
        )


class StatusConfig:
    """
    Configuration for status in a status-stream.
    """

    __slots__ = [
        "__status_level",
        "__status_stream_name",
    ]

    _types_map = {
        "status_level": {"type": StatusLevel, "subtype": None},
        "status_stream_name": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "status_level": {
            "required": False,
        },
        "status_stream_name": {
            "required": False,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
    }

    def __init__(
        self, status_level: StatusLevel = None, status_stream_name: str = None
    ):
        """
        :param status_level: Defines the verbosity of status messages in a status-stream.
        :param status_stream_name: The name of the stream to which status messages are appended.
            The status-stream should be created before associating it with another stream.
        """
        pass
        self.__status_level = status_level
        self.__status_stream_name = status_stream_name

    def _get_status_level(self):
        return self.__status_level

    def _set_status_level(self, value):
        if value is not None and not isinstance(value, StatusLevel):
            raise TypeError("status_level must be StatusLevel")

        self.__status_level = value

    status_level = property(_get_status_level, _set_status_level)
    """
    Defines the verbosity of status messages in a status-stream.
    """

    def _get_status_stream_name(self):
        return self.__status_stream_name

    def _set_status_stream_name(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("status_stream_name must be str")

        self.__status_stream_name = value

    status_stream_name = property(_get_status_stream_name, _set_status_stream_name)
    """
    The name of the stream to which status messages are appended.
    The status-stream should be created before associating it with another stream.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "statusLevel" in d:
            v["status_level"] = (
                StatusLevel.from_dict(d["statusLevel"])
                if hasattr(StatusLevel, "from_dict")
                else d["statusLevel"]
            )
        if "statusStreamName" in d:
            v["status_stream_name"] = (
                str.from_dict(d["statusStreamName"])
                if hasattr(str, "from_dict")
                else d["statusStreamName"]
            )
        return StatusConfig(**v)

    def as_dict(self):
        d = {}
        if self.__status_level is not None:
            d["statusLevel"] = (
                self.__status_level.as_dict()
                if hasattr(self.__status_level, "as_dict")
                else self.__status_level
            )
        if self.__status_stream_name is not None:
            d["statusStreamName"] = (
                self.__status_stream_name.as_dict()
                if hasattr(self.__status_stream_name, "as_dict")
                else self.__status_stream_name
            )
        return d

    def __repr__(self):
        return "<Class StatusConfig. status_level: {}, status_stream_name: {}>".format(
            limitedRepr(
                self.__status_level[:20]
                if isinstance(self.__status_level, bytes)
                else self.__status_level
            ),
            limitedRepr(
                self.__status_stream_name[:20]
                if isinstance(self.__status_stream_name, bytes)
                else self.__status_stream_name
            ),
        )


class S3ExportTaskExecutorConfig:
    """
    Configuration object for S3 export tasks executor.  Minimum version requirements: StreamManager server version 1.1 (or AWS IoT Greengrass Core 1.11.0)
    """

    __slots__ = [
        "__identifier",
        "__size_threshold_for_multipart_upload_bytes",
        "__priority",
        "__disabled",
        "__status_config",
    ]

    _types_map = {
        "identifier": {"type": str, "subtype": None},
        "size_threshold_for_multipart_upload_bytes": {"type": int, "subtype": None},
        "priority": {"type": int, "subtype": None},
        "disabled": {"type": bool, "subtype": None},
        "status_config": {"type": StatusConfig, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "identifier": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "size_threshold_for_multipart_upload_bytes": {
            "required": False,
            "minimum": 5242880,
        },
        "priority": {
            "required": False,
            "maximum": 10,
            "minimum": 1,
        },
        "disabled": {
            "required": False,
        },
        "status_config": {
            "required": False,
        },
    }

    def __init__(
        self,
        identifier: str = None,
        size_threshold_for_multipart_upload_bytes: int = None,
        priority: int = None,
        disabled: bool = None,
        status_config: StatusConfig = None,
    ):
        """
        :param identifier: A unique identifier to identify this individual upload task.
            Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
        :param size_threshold_for_multipart_upload_bytes: The size threshold in bytes for when to use multipart uploads. Uploads over this size will automatically use a multipart upload strategy, while uploads equal or smaller than this threshold will use a single connection to upload the whole object.
        :param priority: Priority for this upload task. Lower values are higher priority. If not specified it will have the lowest priority.
        :param disabled: Enable or disable this export. Default is false.
        :param status_config: Event status configuration that specifies the target status stream and verbosity.
        """
        pass
        self.__identifier = identifier
        self.__size_threshold_for_multipart_upload_bytes = (
            size_threshold_for_multipart_upload_bytes
        )
        self.__priority = priority
        self.__disabled = disabled
        self.__status_config = status_config

    def _get_identifier(self):
        return self.__identifier

    def _set_identifier(self, value):
        if not isinstance(value, str):
            raise TypeError("identifier must be str")

        self.__identifier = value

    identifier = property(_get_identifier, _set_identifier)
    """
    A unique identifier to identify this individual upload task.
    Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
    """

    def _get_size_threshold_for_multipart_upload_bytes(self):
        return self.__size_threshold_for_multipart_upload_bytes

    def _set_size_threshold_for_multipart_upload_bytes(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("size_threshold_for_multipart_upload_bytes must be int")

        self.__size_threshold_for_multipart_upload_bytes = value

    size_threshold_for_multipart_upload_bytes = property(
        _get_size_threshold_for_multipart_upload_bytes,
        _set_size_threshold_for_multipart_upload_bytes,
    )
    """
    The size threshold in bytes for when to use multipart uploads. Uploads over this size will automatically use a multipart upload strategy, while uploads equal or smaller than this threshold will use a single connection to upload the whole object.
    """

    def _get_priority(self):
        return self.__priority

    def _set_priority(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("priority must be int")

        self.__priority = value

    priority = property(_get_priority, _set_priority)
    """
    Priority for this upload task. Lower values are higher priority. If not specified it will have the lowest priority.
    """

    def _get_disabled(self):
        return self.__disabled

    def _set_disabled(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("disabled must be bool")

        self.__disabled = value

    disabled = property(_get_disabled, _set_disabled)
    """
    Enable or disable this export. Default is false.
    """

    def _get_status_config(self):
        return self.__status_config

    def _set_status_config(self, value):
        if value is not None and not isinstance(value, StatusConfig):
            raise TypeError("status_config must be StatusConfig")

        self.__status_config = value

    status_config = property(_get_status_config, _set_status_config)
    """
    Event status configuration that specifies the target status stream and verbosity.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "identifier" in d:
            v["identifier"] = (
                str.from_dict(d["identifier"])
                if hasattr(str, "from_dict")
                else d["identifier"]
            )
        if "sizeThresholdForMultipartUploadBytes" in d:
            v["size_threshold_for_multipart_upload_bytes"] = (
                int.from_dict(d["sizeThresholdForMultipartUploadBytes"])
                if hasattr(int, "from_dict")
                else d["sizeThresholdForMultipartUploadBytes"]
            )
        if "priority" in d:
            v["priority"] = (
                int.from_dict(d["priority"])
                if hasattr(int, "from_dict")
                else d["priority"]
            )
        if "disabled" in d:
            v["disabled"] = (
                bool.from_dict(d["disabled"])
                if hasattr(bool, "from_dict")
                else d["disabled"]
            )
        if "statusConfig" in d:
            v["status_config"] = (
                StatusConfig.from_dict(d["statusConfig"])
                if hasattr(StatusConfig, "from_dict")
                else d["statusConfig"]
            )
        return S3ExportTaskExecutorConfig(**v)

    def as_dict(self):
        d = {}
        if self.__identifier is not None:
            d["identifier"] = (
                self.__identifier.as_dict()
                if hasattr(self.__identifier, "as_dict")
                else self.__identifier
            )
        if self.__size_threshold_for_multipart_upload_bytes is not None:
            d["sizeThresholdForMultipartUploadBytes"] = (
                self.__size_threshold_for_multipart_upload_bytes.as_dict()
                if hasattr(self.__size_threshold_for_multipart_upload_bytes, "as_dict")
                else self.__size_threshold_for_multipart_upload_bytes
            )
        if self.__priority is not None:
            d["priority"] = (
                self.__priority.as_dict()
                if hasattr(self.__priority, "as_dict")
                else self.__priority
            )
        if self.__disabled is not None:
            d["disabled"] = (
                self.__disabled.as_dict()
                if hasattr(self.__disabled, "as_dict")
                else self.__disabled
            )
        if self.__status_config is not None:
            d["statusConfig"] = (
                self.__status_config.as_dict()
                if hasattr(self.__status_config, "as_dict")
                else self.__status_config
            )
        return d

    def __repr__(self):
        return "<Class S3ExportTaskExecutorConfig. identifier: {}, size_threshold_for_multipart_upload_bytes: {}, priority: {}, disabled: {}, status_config: {}>".format(
            limitedRepr(
                self.__identifier[:20]
                if isinstance(self.__identifier, bytes)
                else self.__identifier
            ),
            limitedRepr(
                self.__size_threshold_for_multipart_upload_bytes[:20]
                if isinstance(self.__size_threshold_for_multipart_upload_bytes, bytes)
                else self.__size_threshold_for_multipart_upload_bytes
            ),
            limitedRepr(
                self.__priority[:20]
                if isinstance(self.__priority, bytes)
                else self.__priority
            ),
            limitedRepr(
                self.__disabled[:20]
                if isinstance(self.__disabled, bytes)
                else self.__disabled
            ),
            limitedRepr(
                self.__status_config[:20]
                if isinstance(self.__status_config, bytes)
                else self.__status_config
            ),
        )


class IoTAnalyticsConfig:
    """
    Configuration object for IoT Analytics export destination.
    """

    __slots__ = [
        "__identifier",
        "__iot_channel",
        "__iot_msg_id_prefix",
        "__batch_size",
        "__batch_interval_millis",
        "__priority",
        "__start_sequence_number",
        "__disabled",
    ]

    _types_map = {
        "identifier": {"type": str, "subtype": None},
        "iot_channel": {"type": str, "subtype": None},
        "iot_msg_id_prefix": {"type": str, "subtype": None},
        "batch_size": {"type": int, "subtype": None},
        "batch_interval_millis": {"type": int, "subtype": None},
        "priority": {"type": int, "subtype": None},
        "start_sequence_number": {"type": int, "subtype": None},
        "disabled": {"type": bool, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "identifier": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "iot_channel": {
            "required": True,
            "minLength": 1,
        },
        "iot_msg_id_prefix": {
            "required": False,
            "maxLength": 32,
        },
        "batch_size": {
            "required": False,
            "maximum": 100,
            "minimum": 1,
        },
        "batch_interval_millis": {
            "required": False,
            "maximum": 9223372036854,
            "minimum": 60000,
        },
        "priority": {
            "required": False,
            "maximum": 10,
            "minimum": 1,
        },
        "start_sequence_number": {
            "required": False,
            "maximum": 9223372036854775807,
            "minimum": 0,
        },
        "disabled": {
            "required": False,
        },
    }

    def __init__(
        self,
        identifier: str = None,
        iot_channel: str = None,
        iot_msg_id_prefix: str = None,
        batch_size: int = None,
        batch_interval_millis: int = None,
        priority: int = None,
        start_sequence_number: int = None,
        disabled: bool = None,
    ):
        """
        :param identifier: A unique identifier to identify this individual upload stream.
            Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
        :param iot_channel: The name of the IoT Analytics Channel that this exporter should upload to.
        :param iot_msg_id_prefix: A string prefixed to each unique message id. After this prefix, StreamManager may append more data to make the message ID unique.
            This prefix must be less than 32 characters.
        :param batch_size: The maximum size of a batch to send to IoT Analytics. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 100.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The batch size must be between 1 and 100.
        :param batch_interval_millis: The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
            If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
            The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
        :param priority: Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
        :param start_sequence_number: The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
        :param disabled: Enable or disable this export. Default is false.
        """
        pass
        self.__identifier = identifier
        self.__iot_channel = iot_channel
        self.__iot_msg_id_prefix = iot_msg_id_prefix
        self.__batch_size = batch_size
        self.__batch_interval_millis = batch_interval_millis
        self.__priority = priority
        self.__start_sequence_number = start_sequence_number
        self.__disabled = disabled

    def _get_identifier(self):
        return self.__identifier

    def _set_identifier(self, value):
        if not isinstance(value, str):
            raise TypeError("identifier must be str")

        self.__identifier = value

    identifier = property(_get_identifier, _set_identifier)
    """
    A unique identifier to identify this individual upload stream.
    Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
    """

    def _get_iot_channel(self):
        return self.__iot_channel

    def _set_iot_channel(self, value):
        if not isinstance(value, str):
            raise TypeError("iot_channel must be str")

        self.__iot_channel = value

    iot_channel = property(_get_iot_channel, _set_iot_channel)
    """
    The name of the IoT Analytics Channel that this exporter should upload to.
    """

    def _get_iot_msg_id_prefix(self):
        return self.__iot_msg_id_prefix

    def _set_iot_msg_id_prefix(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("iot_msg_id_prefix must be str")

        self.__iot_msg_id_prefix = value

    iot_msg_id_prefix = property(_get_iot_msg_id_prefix, _set_iot_msg_id_prefix)
    """
    A string prefixed to each unique message id. After this prefix, StreamManager may append more data to make the message ID unique.
    This prefix must be less than 32 characters.
    """

    def _get_batch_size(self):
        return self.__batch_size

    def _set_batch_size(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_size must be int")

        self.__batch_size = value

    batch_size = property(_get_batch_size, _set_batch_size)
    """
    The maximum size of a batch to send to IoT Analytics. Messages will be queued until the batch size is reached, after which they will then be uploaded. If unspecified the default will be 100.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The batch size must be between 1 and 100.
    """

    def _get_batch_interval_millis(self):
        return self.__batch_interval_millis

    def _set_batch_interval_millis(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("batch_interval_millis must be int")

        self.__batch_interval_millis = value

    batch_interval_millis = property(
        _get_batch_interval_millis, _set_batch_interval_millis
    )
    """
    The time in milliseconds between the earliest un-uploaded message and the current time. If this time is exceeded, messages will be uploaded in the next batch. If unspecified messages will be eligible for upload immediately.
    If both batchSize and batchIntervalMillis are specified, then messages will be eligible for upload when either condition is met.
    The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
    """

    def _get_priority(self):
        return self.__priority

    def _set_priority(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("priority must be int")

        self.__priority = value

    priority = property(_get_priority, _set_priority)
    """
    Priority for this upload stream. Lower values are higher priority. If not specified it will have the lowest priority.
    """

    def _get_start_sequence_number(self):
        return self.__start_sequence_number

    def _set_start_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("start_sequence_number must be int")

        self.__start_sequence_number = value

    start_sequence_number = property(
        _get_start_sequence_number, _set_start_sequence_number
    )
    """
    The sequence number of the message to use as the starting message in the export. Default is 0. The sequence number provided should be less than the newest sequence number in the stream, i.e., sequence number of the last messaged appended. To find the newest sequence number, describe the stream and then check the storage status of the returned MessageStreamInfo object.
    """

    def _get_disabled(self):
        return self.__disabled

    def _set_disabled(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("disabled must be bool")

        self.__disabled = value

    disabled = property(_get_disabled, _set_disabled)
    """
    Enable or disable this export. Default is false.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "identifier" in d:
            v["identifier"] = (
                str.from_dict(d["identifier"])
                if hasattr(str, "from_dict")
                else d["identifier"]
            )
        if "iotChannel" in d:
            v["iot_channel"] = (
                str.from_dict(d["iotChannel"])
                if hasattr(str, "from_dict")
                else d["iotChannel"]
            )
        if "iotMsgIdPrefix" in d:
            v["iot_msg_id_prefix"] = (
                str.from_dict(d["iotMsgIdPrefix"])
                if hasattr(str, "from_dict")
                else d["iotMsgIdPrefix"]
            )
        if "batchSize" in d:
            v["batch_size"] = (
                int.from_dict(d["batchSize"])
                if hasattr(int, "from_dict")
                else d["batchSize"]
            )
        if "batchIntervalMillis" in d:
            v["batch_interval_millis"] = (
                int.from_dict(d["batchIntervalMillis"])
                if hasattr(int, "from_dict")
                else d["batchIntervalMillis"]
            )
        if "priority" in d:
            v["priority"] = (
                int.from_dict(d["priority"])
                if hasattr(int, "from_dict")
                else d["priority"]
            )
        if "startSequenceNumber" in d:
            v["start_sequence_number"] = (
                int.from_dict(d["startSequenceNumber"])
                if hasattr(int, "from_dict")
                else d["startSequenceNumber"]
            )
        if "disabled" in d:
            v["disabled"] = (
                bool.from_dict(d["disabled"])
                if hasattr(bool, "from_dict")
                else d["disabled"]
            )
        return IoTAnalyticsConfig(**v)

    def as_dict(self):
        d = {}
        if self.__identifier is not None:
            d["identifier"] = (
                self.__identifier.as_dict()
                if hasattr(self.__identifier, "as_dict")
                else self.__identifier
            )
        if self.__iot_channel is not None:
            d["iotChannel"] = (
                self.__iot_channel.as_dict()
                if hasattr(self.__iot_channel, "as_dict")
                else self.__iot_channel
            )
        if self.__iot_msg_id_prefix is not None:
            d["iotMsgIdPrefix"] = (
                self.__iot_msg_id_prefix.as_dict()
                if hasattr(self.__iot_msg_id_prefix, "as_dict")
                else self.__iot_msg_id_prefix
            )
        if self.__batch_size is not None:
            d["batchSize"] = (
                self.__batch_size.as_dict()
                if hasattr(self.__batch_size, "as_dict")
                else self.__batch_size
            )
        if self.__batch_interval_millis is not None:
            d["batchIntervalMillis"] = (
                self.__batch_interval_millis.as_dict()
                if hasattr(self.__batch_interval_millis, "as_dict")
                else self.__batch_interval_millis
            )
        if self.__priority is not None:
            d["priority"] = (
                self.__priority.as_dict()
                if hasattr(self.__priority, "as_dict")
                else self.__priority
            )
        if self.__start_sequence_number is not None:
            d["startSequenceNumber"] = (
                self.__start_sequence_number.as_dict()
                if hasattr(self.__start_sequence_number, "as_dict")
                else self.__start_sequence_number
            )
        if self.__disabled is not None:
            d["disabled"] = (
                self.__disabled.as_dict()
                if hasattr(self.__disabled, "as_dict")
                else self.__disabled
            )
        return d

    def __repr__(self):
        return "<Class IoTAnalyticsConfig. identifier: {}, iot_channel: {}, iot_msg_id_prefix: {}, batch_size: {}, batch_interval_millis: {}, priority: {}, start_sequence_number: {}, disabled: {}>".format(
            limitedRepr(
                self.__identifier[:20]
                if isinstance(self.__identifier, bytes)
                else self.__identifier
            ),
            limitedRepr(
                self.__iot_channel[:20]
                if isinstance(self.__iot_channel, bytes)
                else self.__iot_channel
            ),
            limitedRepr(
                self.__iot_msg_id_prefix[:20]
                if isinstance(self.__iot_msg_id_prefix, bytes)
                else self.__iot_msg_id_prefix
            ),
            limitedRepr(
                self.__batch_size[:20]
                if isinstance(self.__batch_size, bytes)
                else self.__batch_size
            ),
            limitedRepr(
                self.__batch_interval_millis[:20]
                if isinstance(self.__batch_interval_millis, bytes)
                else self.__batch_interval_millis
            ),
            limitedRepr(
                self.__priority[:20]
                if isinstance(self.__priority, bytes)
                else self.__priority
            ),
            limitedRepr(
                self.__start_sequence_number[:20]
                if isinstance(self.__start_sequence_number, bytes)
                else self.__start_sequence_number
            ),
            limitedRepr(
                self.__disabled[:20]
                if isinstance(self.__disabled, bytes)
                else self.__disabled
            ),
        )


class ExportDefinition:
    """
    Defines how and where the stream is uploaded.
    """

    __slots__ = [
        "__http",
        "__iot_analytics",
        "__kinesis",
        "__iot_sitewise",
        "__s3_task_executor",
    ]

    _types_map = {
        "http": {"type": list, "subtype": HTTPConfig},
        "iot_analytics": {"type": list, "subtype": IoTAnalyticsConfig},
        "kinesis": {"type": list, "subtype": KinesisConfig},
        "iot_sitewise": {"type": list, "subtype": IoTSiteWiseConfig},
        "s3_task_executor": {"type": list, "subtype": S3ExportTaskExecutorConfig},
    }
    _formats_map = {}
    _validations_map = {
        "http": {
            "required": False,
        },
        "iot_analytics": {
            "required": False,
        },
        "kinesis": {
            "required": False,
        },
        "iot_sitewise": {
            "required": False,
        },
        "s3_task_executor": {
            "required": False,
        },
    }

    def __init__(
        self,
        http: List[HTTPConfig] = None,
        iot_analytics: List[IoTAnalyticsConfig] = None,
        kinesis: List[KinesisConfig] = None,
        iot_sitewise: List[IoTSiteWiseConfig] = None,
        s3_task_executor: List[S3ExportTaskExecutorConfig] = None,
    ):
        """
        :param http: Defines how the stream is uploaded to an HTTP endpoint.
        :param iot_analytics: Defines how the stream is uploaded to IoT Analytics.
        :param kinesis: Defines how the stream is uploaded to Kinesis.
        :param iot_sitewise: Defines how the stream is uploaded to IoT SiteWise.
        :param s3_task_executor: Defines the list of configs for S3 task executors.
        """
        pass
        self.__http = http
        self.__iot_analytics = iot_analytics
        self.__kinesis = kinesis
        self.__iot_sitewise = iot_sitewise
        self.__s3_task_executor = s3_task_executor

    def _get_http(self):
        return self.__http

    def _set_http(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("http must be list")
        if value is not None and not all(isinstance(i, HTTPConfig) for i in value):
            raise TypeError("http list values must be HTTPConfig")

        self.__http = value

    http = property(_get_http, _set_http)
    """
    Defines how the stream is uploaded to an HTTP endpoint.
    """

    def _get_iot_analytics(self):
        return self.__iot_analytics

    def _set_iot_analytics(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("iot_analytics must be list")
        if value is not None and not all(
            isinstance(i, IoTAnalyticsConfig) for i in value
        ):
            raise TypeError("iot_analytics list values must be IoTAnalyticsConfig")

        self.__iot_analytics = value

    iot_analytics = property(_get_iot_analytics, _set_iot_analytics)
    """
    Defines how the stream is uploaded to IoT Analytics.
    """

    def _get_kinesis(self):
        return self.__kinesis

    def _set_kinesis(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("kinesis must be list")
        if value is not None and not all(isinstance(i, KinesisConfig) for i in value):
            raise TypeError("kinesis list values must be KinesisConfig")

        self.__kinesis = value

    kinesis = property(_get_kinesis, _set_kinesis)
    """
    Defines how the stream is uploaded to Kinesis.
    """

    def _get_iot_sitewise(self):
        return self.__iot_sitewise

    def _set_iot_sitewise(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("iot_sitewise must be list")
        if value is not None and not all(
            isinstance(i, IoTSiteWiseConfig) for i in value
        ):
            raise TypeError("iot_sitewise list values must be IoTSiteWiseConfig")

        self.__iot_sitewise = value

    iot_sitewise = property(_get_iot_sitewise, _set_iot_sitewise)
    """
    Defines how the stream is uploaded to IoT SiteWise.
    """

    def _get_s3_task_executor(self):
        return self.__s3_task_executor

    def _set_s3_task_executor(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("s3_task_executor must be list")
        if value is not None and not all(
            isinstance(i, S3ExportTaskExecutorConfig) for i in value
        ):
            raise TypeError(
                "s3_task_executor list values must be S3ExportTaskExecutorConfig"
            )

        self.__s3_task_executor = value

    s3_task_executor = property(_get_s3_task_executor, _set_s3_task_executor)
    """
    Defines the list of configs for S3 task executors.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "http" in d:
            v["http"] = [
                HTTPConfig.from_dict(p) if hasattr(HTTPConfig, "from_dict") else p
                for p in d["http"]
            ]
        if "iotAnalytics" in d:
            v["iot_analytics"] = [
                IoTAnalyticsConfig.from_dict(p)
                if hasattr(IoTAnalyticsConfig, "from_dict")
                else p
                for p in d["iotAnalytics"]
            ]
        if "kinesis" in d:
            v["kinesis"] = [
                KinesisConfig.from_dict(p) if hasattr(KinesisConfig, "from_dict") else p
                for p in d["kinesis"]
            ]
        if "IotSitewise" in d:
            v["iot_sitewise"] = [
                IoTSiteWiseConfig.from_dict(p)
                if hasattr(IoTSiteWiseConfig, "from_dict")
                else p
                for p in d["IotSitewise"]
            ]
        if "s3TaskExecutor" in d:
            v["s3_task_executor"] = [
                S3ExportTaskExecutorConfig.from_dict(p)
                if hasattr(S3ExportTaskExecutorConfig, "from_dict")
                else p
                for p in d["s3TaskExecutor"]
            ]
        return ExportDefinition(**v)

    def as_dict(self):
        d = {}
        if self.__http is not None:
            d["http"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__http
            ]
        if self.__iot_analytics is not None:
            d["iotAnalytics"] = [
                p.as_dict() if hasattr(p, "as_dict") else p
                for p in self.__iot_analytics
            ]
        if self.__kinesis is not None:
            d["kinesis"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__kinesis
            ]
        if self.__iot_sitewise is not None:
            d["IotSitewise"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__iot_sitewise
            ]
        if self.__s3_task_executor is not None:
            d["s3TaskExecutor"] = [
                p.as_dict() if hasattr(p, "as_dict") else p
                for p in self.__s3_task_executor
            ]
        return d

    def __repr__(self):
        return "<Class ExportDefinition. http: {}, iot_analytics: {}, kinesis: {}, iot_sitewise: {}, s3_task_executor: {}>".format(
            limitedRepr(
                self.__http[:20] if isinstance(self.__http, bytes) else self.__http
            ),
            limitedRepr(
                self.__iot_analytics[:20]
                if isinstance(self.__iot_analytics, bytes)
                else self.__iot_analytics
            ),
            limitedRepr(
                self.__kinesis[:20]
                if isinstance(self.__kinesis, bytes)
                else self.__kinesis
            ),
            limitedRepr(
                self.__iot_sitewise[:20]
                if isinstance(self.__iot_sitewise, bytes)
                else self.__iot_sitewise
            ),
            limitedRepr(
                self.__s3_task_executor[:20]
                if isinstance(self.__s3_task_executor, bytes)
                else self.__s3_task_executor
            ),
        )


class StrategyOnFull(enum.Enum):
    """
    StrategyOnFull is used in the MessageStreamDefinition when creating a stream.
    It defines the behavior when the stream has reached the maximum size.
    RejectNewData: any append message request after the stream is full will be rejected with an exception.
    OverwriteOldestData: the oldest stream segments will be deleted until there is room for the new message.
    """

    RejectNewData = 0
    OverwriteOldestData = 1

    @staticmethod
    def from_dict(d):
        return StrategyOnFull(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum StrategyOnFull. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class Persistence(enum.Enum):
    """
    Stream persistence. If set to File, the file system will be used to persist messages long-term and is resilient to restarts.
    Memory should be used when performance matters more than durability as it only stores the stream in memory and never writes to the disk.
    """

    File = 0
    Memory = 1

    @staticmethod
    def from_dict(d):
        return Persistence(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum Persistence. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class MessageStreamDefinition:
    """
    Object defining a message stream used in the CreateMessageStream and UpdateMessageStream API.
    """

    __slots__ = [
        "__name",
        "__max_size",
        "__stream_segment_size",
        "__time_to_live_millis",
        "__strategy_on_full",
        "__persistence",
        "__flush_on_write",
        "__export_definition",
    ]

    _types_map = {
        "name": {"type": str, "subtype": None},
        "max_size": {"type": int, "subtype": None},
        "stream_segment_size": {"type": int, "subtype": None},
        "time_to_live_millis": {"type": int, "subtype": None},
        "strategy_on_full": {"type": StrategyOnFull, "subtype": None},
        "persistence": {"type": Persistence, "subtype": None},
        "flush_on_write": {"type": bool, "subtype": None},
        "export_definition": {"type": ExportDefinition, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "name": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "max_size": {
            "required": False,
            "maximum": 9223372036854775807,
            "minimum": 1024,
        },
        "stream_segment_size": {
            "required": False,
            "maximum": 2147483647,
            "minimum": 1024,
        },
        "time_to_live_millis": {
            "required": False,
            "maximum": 9223372036854,
            "minimum": 60000,
        },
        "strategy_on_full": {
            "required": True,
        },
        "persistence": {
            "required": False,
        },
        "flush_on_write": {
            "required": False,
        },
        "export_definition": {
            "required": False,
        },
    }

    def __init__(
        self,
        name: str = None,
        max_size: int = 268435456,
        stream_segment_size: int = 16777216,
        time_to_live_millis: int = None,
        strategy_on_full: StrategyOnFull = None,
        persistence: Persistence = None,
        flush_on_write: bool = None,
        export_definition: ExportDefinition = None,
    ):
        """
        :param name: The unique name of the stream.
            Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
        :param max_size: The maximum size in bytes for the entire stream. Set to 256MB by default with a minimum of 1KB and a maximum of 8192PB.
        :param stream_segment_size: The size of each segment of the stream. Set to 16MB by default with a minimum of 1KB and a maximum of 2GB.
            Data is only deleted segment by segment, so the segment size is the smallest amount of data which can be deleted.
        :param time_to_live_millis: Time to live for each message in milliseconds. Data may be deleted at any time after the TTL expires; deletion is not guaranteed to occur immediately when the TTL expires.
            The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
        :param strategy_on_full: What to do when the maximum size of the stream is reached.
            RejectNewData: any append message request after the stream is full will be rejected with an exception.
            OverwriteOldestData: the oldest stream segments will be deleted until there is room for the new message.
        :param persistence: Stream persistence. If set to File, the file system will be used to persist messages long-term and is resilient to restarts.
            Memory should be used when performance matters more than durability as it only stores the stream in memory and never writes to the disk.
        :param flush_on_write: This only applies when Persistence is set to File mode.
            Waits for the filesystem to complete the write for every message. This is safer, but slower. Default is false.
        :param export_definition: Defines how and where the stream is uploaded. See the definition of the ExportDefinition object for more detail.
        """
        pass
        self.__name = name
        self.__max_size = max_size
        self.__stream_segment_size = stream_segment_size
        self.__time_to_live_millis = time_to_live_millis
        self.__strategy_on_full = strategy_on_full
        self.__persistence = persistence
        self.__flush_on_write = flush_on_write
        self.__export_definition = export_definition

    def _get_name(self):
        return self.__name

    def _set_name(self, value):
        if not isinstance(value, str):
            raise TypeError("name must be str")

        self.__name = value

    name = property(_get_name, _set_name)
    """
    The unique name of the stream.
    Must be an alphanumeric string including spaces, commas, periods, hyphens, and underscores with length between 1 and 255.
    """

    def _get_max_size(self):
        return self.__max_size

    def _set_max_size(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("max_size must be int")

        self.__max_size = value

    max_size = property(_get_max_size, _set_max_size)
    """
    The maximum size in bytes for the entire stream. Set to 256MB by default with a minimum of 1KB and a maximum of 8192PB.
    """

    def _get_stream_segment_size(self):
        return self.__stream_segment_size

    def _set_stream_segment_size(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("stream_segment_size must be int")

        self.__stream_segment_size = value

    stream_segment_size = property(_get_stream_segment_size, _set_stream_segment_size)
    """
    The size of each segment of the stream. Set to 16MB by default with a minimum of 1KB and a maximum of 2GB.
    Data is only deleted segment by segment, so the segment size is the smallest amount of data which can be deleted.
    """

    def _get_time_to_live_millis(self):
        return self.__time_to_live_millis

    def _set_time_to_live_millis(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("time_to_live_millis must be int")

        self.__time_to_live_millis = value

    time_to_live_millis = property(_get_time_to_live_millis, _set_time_to_live_millis)
    """
    Time to live for each message in milliseconds. Data may be deleted at any time after the TTL expires; deletion is not guaranteed to occur immediately when the TTL expires.
    The minimum value is 60000 milliseconds and the maximum is 9223372036854 milliseconds.
    """

    def _get_strategy_on_full(self):
        return self.__strategy_on_full

    def _set_strategy_on_full(self, value):
        if not isinstance(value, StrategyOnFull):
            raise TypeError("strategy_on_full must be StrategyOnFull")

        self.__strategy_on_full = value

    strategy_on_full = property(_get_strategy_on_full, _set_strategy_on_full)
    """
    What to do when the maximum size of the stream is reached.
    RejectNewData: any append message request after the stream is full will be rejected with an exception.
    OverwriteOldestData: the oldest stream segments will be deleted until there is room for the new message.
    """

    def _get_persistence(self):
        return self.__persistence

    def _set_persistence(self, value):
        if value is not None and not isinstance(value, Persistence):
            raise TypeError("persistence must be Persistence")

        self.__persistence = value

    persistence = property(_get_persistence, _set_persistence)
    """
    Stream persistence. If set to File, the file system will be used to persist messages long-term and is resilient to restarts.
    Memory should be used when performance matters more than durability as it only stores the stream in memory and never writes to the disk.
    """

    def _get_flush_on_write(self):
        return self.__flush_on_write

    def _set_flush_on_write(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("flush_on_write must be bool")

        self.__flush_on_write = value

    flush_on_write = property(_get_flush_on_write, _set_flush_on_write)
    """
    This only applies when Persistence is set to File mode.
    Waits for the filesystem to complete the write for every message. This is safer, but slower. Default is false.
    """

    def _get_export_definition(self):
        return self.__export_definition

    def _set_export_definition(self, value):
        if value is not None and not isinstance(value, ExportDefinition):
            raise TypeError("export_definition must be ExportDefinition")

        self.__export_definition = value

    export_definition = property(_get_export_definition, _set_export_definition)
    """
    Defines how and where the stream is uploaded. See the definition of the ExportDefinition object for more detail.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "name" in d:
            v["name"] = (
                str.from_dict(d["name"]) if hasattr(str, "from_dict") else d["name"]
            )
        if "maxSize" in d:
            v["max_size"] = (
                int.from_dict(d["maxSize"])
                if hasattr(int, "from_dict")
                else d["maxSize"]
            )
        if "streamSegmentSize" in d:
            v["stream_segment_size"] = (
                int.from_dict(d["streamSegmentSize"])
                if hasattr(int, "from_dict")
                else d["streamSegmentSize"]
            )
        if "timeToLiveMillis" in d:
            v["time_to_live_millis"] = (
                int.from_dict(d["timeToLiveMillis"])
                if hasattr(int, "from_dict")
                else d["timeToLiveMillis"]
            )
        if "strategyOnFull" in d:
            v["strategy_on_full"] = (
                StrategyOnFull.from_dict(d["strategyOnFull"])
                if hasattr(StrategyOnFull, "from_dict")
                else d["strategyOnFull"]
            )
        if "persistence" in d:
            v["persistence"] = (
                Persistence.from_dict(d["persistence"])
                if hasattr(Persistence, "from_dict")
                else d["persistence"]
            )
        if "flushOnWrite" in d:
            v["flush_on_write"] = (
                bool.from_dict(d["flushOnWrite"])
                if hasattr(bool, "from_dict")
                else d["flushOnWrite"]
            )
        if "exportDefinition" in d:
            v["export_definition"] = (
                ExportDefinition.from_dict(d["exportDefinition"])
                if hasattr(ExportDefinition, "from_dict")
                else d["exportDefinition"]
            )
        return MessageStreamDefinition(**v)

    def as_dict(self):
        d = {}
        if self.__name is not None:
            d["name"] = (
                self.__name.as_dict()
                if hasattr(self.__name, "as_dict")
                else self.__name
            )
        if self.__max_size is not None:
            d["maxSize"] = (
                self.__max_size.as_dict()
                if hasattr(self.__max_size, "as_dict")
                else self.__max_size
            )
        if self.__stream_segment_size is not None:
            d["streamSegmentSize"] = (
                self.__stream_segment_size.as_dict()
                if hasattr(self.__stream_segment_size, "as_dict")
                else self.__stream_segment_size
            )
        if self.__time_to_live_millis is not None:
            d["timeToLiveMillis"] = (
                self.__time_to_live_millis.as_dict()
                if hasattr(self.__time_to_live_millis, "as_dict")
                else self.__time_to_live_millis
            )
        if self.__strategy_on_full is not None:
            d["strategyOnFull"] = (
                self.__strategy_on_full.as_dict()
                if hasattr(self.__strategy_on_full, "as_dict")
                else self.__strategy_on_full
            )
        if self.__persistence is not None:
            d["persistence"] = (
                self.__persistence.as_dict()
                if hasattr(self.__persistence, "as_dict")
                else self.__persistence
            )
        if self.__flush_on_write is not None:
            d["flushOnWrite"] = (
                self.__flush_on_write.as_dict()
                if hasattr(self.__flush_on_write, "as_dict")
                else self.__flush_on_write
            )
        if self.__export_definition is not None:
            d["exportDefinition"] = (
                self.__export_definition.as_dict()
                if hasattr(self.__export_definition, "as_dict")
                else self.__export_definition
            )
        return d

    def __repr__(self):
        return "<Class MessageStreamDefinition. name: {}, max_size: {}, stream_segment_size: {}, time_to_live_millis: {}, strategy_on_full: {}, persistence: {}, flush_on_write: {}, export_definition: {}>".format(
            limitedRepr(
                self.__name[:20] if isinstance(self.__name, bytes) else self.__name
            ),
            limitedRepr(
                self.__max_size[:20]
                if isinstance(self.__max_size, bytes)
                else self.__max_size
            ),
            limitedRepr(
                self.__stream_segment_size[:20]
                if isinstance(self.__stream_segment_size, bytes)
                else self.__stream_segment_size
            ),
            limitedRepr(
                self.__time_to_live_millis[:20]
                if isinstance(self.__time_to_live_millis, bytes)
                else self.__time_to_live_millis
            ),
            limitedRepr(
                self.__strategy_on_full[:20]
                if isinstance(self.__strategy_on_full, bytes)
                else self.__strategy_on_full
            ),
            limitedRepr(
                self.__persistence[:20]
                if isinstance(self.__persistence, bytes)
                else self.__persistence
            ),
            limitedRepr(
                self.__flush_on_write[:20]
                if isinstance(self.__flush_on_write, bytes)
                else self.__flush_on_write
            ),
            limitedRepr(
                self.__export_definition[:20]
                if isinstance(self.__export_definition, bytes)
                else self.__export_definition
            ),
        )


class CreateMessageStreamRequest:
    """
    (Internal Only) Request object for creating a message stream.
    """

    __slots__ = [
        "__request_id",
        "__definition",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "definition": {"type": MessageStreamDefinition, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "definition": {
            "required": True,
        },
    }

    def __init__(
        self, request_id: str = None, definition: MessageStreamDefinition = None
    ):
        pass
        self.__request_id = request_id
        self.__definition = definition

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_definition(self):
        return self.__definition

    def _set_definition(self, value):
        if not isinstance(value, MessageStreamDefinition):
            raise TypeError("definition must be MessageStreamDefinition")

        self.__definition = value

    definition = property(_get_definition, _set_definition)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "definition" in d:
            v["definition"] = (
                MessageStreamDefinition.from_dict(d["definition"])
                if hasattr(MessageStreamDefinition, "from_dict")
                else d["definition"]
            )
        return CreateMessageStreamRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__definition is not None:
            d["definition"] = (
                self.__definition.as_dict()
                if hasattr(self.__definition, "as_dict")
                else self.__definition
            )
        return d

    def __repr__(self):
        return (
            "<Class CreateMessageStreamRequest. request_id: {}, definition: {}>".format(
                limitedRepr(
                    self.__request_id[:20]
                    if isinstance(self.__request_id, bytes)
                    else self.__request_id
                ),
                limitedRepr(
                    self.__definition[:20]
                    if isinstance(self.__definition, bytes)
                    else self.__definition
                ),
            )
        )


class CreateMessageStreamResponse:
    """
    Internal Only.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        return CreateMessageStreamResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        return d

    def __repr__(self):
        return "<Class CreateMessageStreamResponse. request_id: {}, status: {}, error_message: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
        )


class UpdateMessageStreamRequest:
    """
    (Internal Only) Request object for updating a message stream.
    """

    __slots__ = [
        "__request_id",
        "__definition",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "definition": {"type": MessageStreamDefinition, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "definition": {
            "required": True,
        },
    }

    def __init__(
        self, request_id: str = None, definition: MessageStreamDefinition = None
    ):
        pass
        self.__request_id = request_id
        self.__definition = definition

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_definition(self):
        return self.__definition

    def _set_definition(self, value):
        if not isinstance(value, MessageStreamDefinition):
            raise TypeError("definition must be MessageStreamDefinition")

        self.__definition = value

    definition = property(_get_definition, _set_definition)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "definition" in d:
            v["definition"] = (
                MessageStreamDefinition.from_dict(d["definition"])
                if hasattr(MessageStreamDefinition, "from_dict")
                else d["definition"]
            )
        return UpdateMessageStreamRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__definition is not None:
            d["definition"] = (
                self.__definition.as_dict()
                if hasattr(self.__definition, "as_dict")
                else self.__definition
            )
        return d

    def __repr__(self):
        return (
            "<Class UpdateMessageStreamRequest. request_id: {}, definition: {}>".format(
                limitedRepr(
                    self.__request_id[:20]
                    if isinstance(self.__request_id, bytes)
                    else self.__request_id
                ),
                limitedRepr(
                    self.__definition[:20]
                    if isinstance(self.__definition, bytes)
                    else self.__definition
                ),
            )
        )


class UpdateMessageStreamResponse:
    """
    (Internal Only) Response for UpdateMessageStreamRequest.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        return UpdateMessageStreamResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        return d

    def __repr__(self):
        return "<Class UpdateMessageStreamResponse. request_id: {}, status: {}, error_message: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
        )


class DeleteMessageStreamRequest:
    """
    (Internal Only) Request object for deleting a message stream.
    """

    __slots__ = [
        "__request_id",
        "__name",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "name": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "name": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
    }

    def __init__(self, request_id: str = None, name: str = None):
        pass
        self.__request_id = request_id
        self.__name = name

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_name(self):
        return self.__name

    def _set_name(self, value):
        if not isinstance(value, str):
            raise TypeError("name must be str")

        self.__name = value

    name = property(_get_name, _set_name)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "name" in d:
            v["name"] = (
                str.from_dict(d["name"]) if hasattr(str, "from_dict") else d["name"]
            )
        return DeleteMessageStreamRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__name is not None:
            d["name"] = (
                self.__name.as_dict()
                if hasattr(self.__name, "as_dict")
                else self.__name
            )
        return d

    def __repr__(self):
        return "<Class DeleteMessageStreamRequest. request_id: {}, name: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__name[:20] if isinstance(self.__name, bytes) else self.__name
            ),
        )


class DeleteMessageStreamResponse:
    """
    Internal Only.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        return DeleteMessageStreamResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        return d

    def __repr__(self):
        return "<Class DeleteMessageStreamResponse. request_id: {}, status: {}, error_message: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
        )


class DescribeMessageStreamRequest:
    """
    (Internal Only) Request object for describing a message stream.
    """

    __slots__ = [
        "__request_id",
        "__name",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "name": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "name": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
    }

    def __init__(self, request_id: str = None, name: str = None):
        pass
        self.__request_id = request_id
        self.__name = name

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_name(self):
        return self.__name

    def _set_name(self, value):
        if not isinstance(value, str):
            raise TypeError("name must be str")

        self.__name = value

    name = property(_get_name, _set_name)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "name" in d:
            v["name"] = (
                str.from_dict(d["name"]) if hasattr(str, "from_dict") else d["name"]
            )
        return DescribeMessageStreamRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__name is not None:
            d["name"] = (
                self.__name.as_dict()
                if hasattr(self.__name, "as_dict")
                else self.__name
            )
        return d

    def __repr__(self):
        return "<Class DescribeMessageStreamRequest. request_id: {}, name: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__name[:20] if isinstance(self.__name, bytes) else self.__name
            ),
        )


class MessageStreamInfo:
    """
    Message stream information including its definition, storage status and export status.
    """

    class storageStatus:
        """
        Stream status including oldest/newest sequence number and total bytes.
        """

        __slots__ = [
            "__oldest_sequence_number",
            "__newest_sequence_number",
            "__total_bytes",
        ]

        _types_map = {
            "oldest_sequence_number": {"type": int, "subtype": None},
            "newest_sequence_number": {"type": int, "subtype": None},
            "total_bytes": {"type": int, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "oldest_sequence_number": {
                "required": False,
            },
            "newest_sequence_number": {
                "required": False,
            },
            "total_bytes": {
                "required": False,
            },
        }

        def __init__(
            self,
            oldest_sequence_number: int = None,
            newest_sequence_number: int = None,
            total_bytes: int = None,
        ):
            """
            :param oldest_sequence_number: The sequence number of the first message which is still accessible in the stream.
            :param newest_sequence_number: The sequence number of the last appended message.
            :param total_bytes: The current total size of the stream in bytes.
            """
            pass
            self.__oldest_sequence_number = oldest_sequence_number
            self.__newest_sequence_number = newest_sequence_number
            self.__total_bytes = total_bytes

        def _get_oldest_sequence_number(self):
            return self.__oldest_sequence_number

        def _set_oldest_sequence_number(self, value):
            if value is not None and not isinstance(value, int):
                raise TypeError("oldest_sequence_number must be int")

            self.__oldest_sequence_number = value

        oldest_sequence_number = property(
            _get_oldest_sequence_number, _set_oldest_sequence_number
        )
        """
            The sequence number of the first message which is still accessible in the stream.
            """

        def _get_newest_sequence_number(self):
            return self.__newest_sequence_number

        def _set_newest_sequence_number(self, value):
            if value is not None and not isinstance(value, int):
                raise TypeError("newest_sequence_number must be int")

            self.__newest_sequence_number = value

        newest_sequence_number = property(
            _get_newest_sequence_number, _set_newest_sequence_number
        )
        """
            The sequence number of the last appended message.
            """

        def _get_total_bytes(self):
            return self.__total_bytes

        def _set_total_bytes(self, value):
            if value is not None and not isinstance(value, int):
                raise TypeError("total_bytes must be int")

            self.__total_bytes = value

        total_bytes = property(_get_total_bytes, _set_total_bytes)
        """
            The current total size of the stream in bytes.
            """

        @staticmethod
        def from_dict(d):
            v = {}
            if "oldestSequenceNumber" in d:
                v["oldest_sequence_number"] = (
                    int.from_dict(d["oldestSequenceNumber"])
                    if hasattr(int, "from_dict")
                    else d["oldestSequenceNumber"]
                )
            if "newestSequenceNumber" in d:
                v["newest_sequence_number"] = (
                    int.from_dict(d["newestSequenceNumber"])
                    if hasattr(int, "from_dict")
                    else d["newestSequenceNumber"]
                )
            if "totalBytes" in d:
                v["total_bytes"] = (
                    int.from_dict(d["totalBytes"])
                    if hasattr(int, "from_dict")
                    else d["totalBytes"]
                )
            return MessageStreamInfo.storageStatus(**v)

        def as_dict(self):
            d = {}
            if self.__oldest_sequence_number is not None:
                d["oldestSequenceNumber"] = (
                    self.__oldest_sequence_number.as_dict()
                    if hasattr(self.__oldest_sequence_number, "as_dict")
                    else self.__oldest_sequence_number
                )
            if self.__newest_sequence_number is not None:
                d["newestSequenceNumber"] = (
                    self.__newest_sequence_number.as_dict()
                    if hasattr(self.__newest_sequence_number, "as_dict")
                    else self.__newest_sequence_number
                )
            if self.__total_bytes is not None:
                d["totalBytes"] = (
                    self.__total_bytes.as_dict()
                    if hasattr(self.__total_bytes, "as_dict")
                    else self.__total_bytes
                )
            return d

        def __repr__(self):
            return "<Class storageStatus. oldest_sequence_number: {}, newest_sequence_number: {}, total_bytes: {}>".format(
                limitedRepr(
                    self.__oldest_sequence_number[:20]
                    if isinstance(self.__oldest_sequence_number, bytes)
                    else self.__oldest_sequence_number
                ),
                limitedRepr(
                    self.__newest_sequence_number[:20]
                    if isinstance(self.__newest_sequence_number, bytes)
                    else self.__newest_sequence_number
                ),
                limitedRepr(
                    self.__total_bytes[:20]
                    if isinstance(self.__total_bytes, bytes)
                    else self.__total_bytes
                ),
            )

    class exportStatuses:
        """
        Export status including the export identifier and the last exported sequence number for that export task.
        """

        __slots__ = [
            "__export_config_identifier",
            "__last_exported_sequence_number",
            "__last_export_time",
            "__error_message",
            "__exported_bytes_from_stream",
            "__exported_messages_count",
        ]

        _types_map = {
            "export_config_identifier": {"type": str, "subtype": None},
            "last_exported_sequence_number": {"type": int, "subtype": None},
            "last_export_time": {"type": int, "subtype": None},
            "error_message": {"type": str, "subtype": None},
            "exported_bytes_from_stream": {"type": int, "subtype": None},
            "exported_messages_count": {"type": int, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "export_config_identifier": {
                "required": False,
            },
            "last_exported_sequence_number": {
                "required": True,
            },
            "last_export_time": {
                "required": False,
            },
            "error_message": {
                "required": False,
            },
            "exported_bytes_from_stream": {
                "required": False,
            },
            "exported_messages_count": {
                "required": False,
            },
        }

        def __init__(
            self,
            export_config_identifier: str = None,
            last_exported_sequence_number: int = None,
            last_export_time: int = None,
            error_message: str = None,
            exported_bytes_from_stream: int = None,
            exported_messages_count: int = None,
        ):
            """
            :param export_config_identifier: The unique export identifier.
            :param last_exported_sequence_number: The sequence number of the last message which was successfully exported.
            :param last_export_time: The last time an export was attempted. Data is Unix epoch time in milliseconds.
            :param error_message: Error message from the last export attempt if it failed.
            :param exported_bytes_from_stream: Total bytes exported from the stream for this Export Config. It does not include the failed export attempts or messages which are skipped because of some non-retryable error.
            :param exported_messages_count: Total messages exported/processed.
            """
            pass
            self.__export_config_identifier = export_config_identifier
            self.__last_exported_sequence_number = last_exported_sequence_number
            self.__last_export_time = last_export_time
            self.__error_message = error_message
            self.__exported_bytes_from_stream = exported_bytes_from_stream
            self.__exported_messages_count = exported_messages_count

        def _get_export_config_identifier(self):
            return self.__export_config_identifier

        def _set_export_config_identifier(self, value):
            if value is not None and not isinstance(value, str):
                raise TypeError("export_config_identifier must be str")

            self.__export_config_identifier = value

        export_config_identifier = property(
            _get_export_config_identifier, _set_export_config_identifier
        )
        """
            The unique export identifier.
            """

        def _get_last_exported_sequence_number(self):
            return self.__last_exported_sequence_number

        def _set_last_exported_sequence_number(self, value):
            if not isinstance(value, int):
                raise TypeError("last_exported_sequence_number must be int")

            self.__last_exported_sequence_number = value

        last_exported_sequence_number = property(
            _get_last_exported_sequence_number, _set_last_exported_sequence_number
        )
        """
            The sequence number of the last message which was successfully exported.
            """

        def _get_last_export_time(self):
            return self.__last_export_time

        def _set_last_export_time(self, value):
            if value is not None and not isinstance(value, int):
                raise TypeError("last_export_time must be int")

            self.__last_export_time = value

        last_export_time = property(_get_last_export_time, _set_last_export_time)
        """
            The last time an export was attempted. Data is Unix epoch time in milliseconds.
            """

        def _get_error_message(self):
            return self.__error_message

        def _set_error_message(self, value):
            if value is not None and not isinstance(value, str):
                raise TypeError("error_message must be str")

            self.__error_message = value

        error_message = property(_get_error_message, _set_error_message)
        """
            Error message from the last export attempt if it failed.
            """

        def _get_exported_bytes_from_stream(self):
            return self.__exported_bytes_from_stream

        def _set_exported_bytes_from_stream(self, value):
            if value is not None and not isinstance(value, int):
                raise TypeError("exported_bytes_from_stream must be int")

            self.__exported_bytes_from_stream = value

        exported_bytes_from_stream = property(
            _get_exported_bytes_from_stream, _set_exported_bytes_from_stream
        )
        """
            Total bytes exported from the stream for this Export Config. It does not include the failed export attempts or messages which are skipped because of some non-retryable error.
            """

        def _get_exported_messages_count(self):
            return self.__exported_messages_count

        def _set_exported_messages_count(self, value):
            if value is not None and not isinstance(value, int):
                raise TypeError("exported_messages_count must be int")

            self.__exported_messages_count = value

        exported_messages_count = property(
            _get_exported_messages_count, _set_exported_messages_count
        )
        """
            Total messages exported/processed.
            """

        @staticmethod
        def from_dict(d):
            v = {}
            if "exportConfigIdentifier" in d:
                v["export_config_identifier"] = (
                    str.from_dict(d["exportConfigIdentifier"])
                    if hasattr(str, "from_dict")
                    else d["exportConfigIdentifier"]
                )
            if "lastExportedSequenceNumber" in d:
                v["last_exported_sequence_number"] = (
                    int.from_dict(d["lastExportedSequenceNumber"])
                    if hasattr(int, "from_dict")
                    else d["lastExportedSequenceNumber"]
                )
            if "lastExportTime" in d:
                v["last_export_time"] = (
                    int.from_dict(d["lastExportTime"])
                    if hasattr(int, "from_dict")
                    else d["lastExportTime"]
                )
            if "errorMessage" in d:
                v["error_message"] = (
                    str.from_dict(d["errorMessage"])
                    if hasattr(str, "from_dict")
                    else d["errorMessage"]
                )
            if "exportedBytesFromStream" in d:
                v["exported_bytes_from_stream"] = (
                    int.from_dict(d["exportedBytesFromStream"])
                    if hasattr(int, "from_dict")
                    else d["exportedBytesFromStream"]
                )
            if "exportedMessagesCount" in d:
                v["exported_messages_count"] = (
                    int.from_dict(d["exportedMessagesCount"])
                    if hasattr(int, "from_dict")
                    else d["exportedMessagesCount"]
                )
            return MessageStreamInfo.exportStatuses(**v)

        def as_dict(self):
            d = {}
            if self.__export_config_identifier is not None:
                d["exportConfigIdentifier"] = (
                    self.__export_config_identifier.as_dict()
                    if hasattr(self.__export_config_identifier, "as_dict")
                    else self.__export_config_identifier
                )
            if self.__last_exported_sequence_number is not None:
                d["lastExportedSequenceNumber"] = (
                    self.__last_exported_sequence_number.as_dict()
                    if hasattr(self.__last_exported_sequence_number, "as_dict")
                    else self.__last_exported_sequence_number
                )
            if self.__last_export_time is not None:
                d["lastExportTime"] = (
                    self.__last_export_time.as_dict()
                    if hasattr(self.__last_export_time, "as_dict")
                    else self.__last_export_time
                )
            if self.__error_message is not None:
                d["errorMessage"] = (
                    self.__error_message.as_dict()
                    if hasattr(self.__error_message, "as_dict")
                    else self.__error_message
                )
            if self.__exported_bytes_from_stream is not None:
                d["exportedBytesFromStream"] = (
                    self.__exported_bytes_from_stream.as_dict()
                    if hasattr(self.__exported_bytes_from_stream, "as_dict")
                    else self.__exported_bytes_from_stream
                )
            if self.__exported_messages_count is not None:
                d["exportedMessagesCount"] = (
                    self.__exported_messages_count.as_dict()
                    if hasattr(self.__exported_messages_count, "as_dict")
                    else self.__exported_messages_count
                )
            return d

        def __repr__(self):
            return "<Class exportStatuses. export_config_identifier: {}, last_exported_sequence_number: {}, last_export_time: {}, error_message: {}, exported_bytes_from_stream: {}, exported_messages_count: {}>".format(
                limitedRepr(
                    self.__export_config_identifier[:20]
                    if isinstance(self.__export_config_identifier, bytes)
                    else self.__export_config_identifier
                ),
                limitedRepr(
                    self.__last_exported_sequence_number[:20]
                    if isinstance(self.__last_exported_sequence_number, bytes)
                    else self.__last_exported_sequence_number
                ),
                limitedRepr(
                    self.__last_export_time[:20]
                    if isinstance(self.__last_export_time, bytes)
                    else self.__last_export_time
                ),
                limitedRepr(
                    self.__error_message[:20]
                    if isinstance(self.__error_message, bytes)
                    else self.__error_message
                ),
                limitedRepr(
                    self.__exported_bytes_from_stream[:20]
                    if isinstance(self.__exported_bytes_from_stream, bytes)
                    else self.__exported_bytes_from_stream
                ),
                limitedRepr(
                    self.__exported_messages_count[:20]
                    if isinstance(self.__exported_messages_count, bytes)
                    else self.__exported_messages_count
                ),
            )

    __slots__ = [
        "__definition",
        "__storage_status",
        "__export_statuses",
    ]

    _types_map = {
        "definition": {"type": MessageStreamDefinition, "subtype": None},
        "storage_status": {"type": storageStatus, "subtype": None},
        "export_statuses": {"type": list, "subtype": exportStatuses},
    }
    _formats_map = {}
    _validations_map = {
        "definition": {
            "required": True,
        },
        "storage_status": {
            "required": True,
        },
        "export_statuses": {
            "required": False,
        },
    }

    def __init__(
        self,
        definition: MessageStreamDefinition = None,
        storage_status: storageStatus = None,
        export_statuses: List[exportStatuses] = None,
    ):
        """
        :param storage_status: Stream status including oldest/newest sequence number and total bytes.
        """
        pass
        self.__definition = definition
        self.__storage_status = storage_status
        self.__export_statuses = export_statuses

    def _get_definition(self):
        return self.__definition

    def _set_definition(self, value):
        if not isinstance(value, MessageStreamDefinition):
            raise TypeError("definition must be MessageStreamDefinition")

        self.__definition = value

    definition = property(_get_definition, _set_definition)

    def _get_storage_status(self):
        return self.__storage_status

    def _set_storage_status(self, value):
        if not isinstance(value, MessageStreamInfo.storageStatus):
            raise TypeError("storage_status must be MessageStreamInfo.storageStatus")

        self.__storage_status = value

    storage_status = property(_get_storage_status, _set_storage_status)
    """
    Stream status including oldest/newest sequence number and total bytes.
    """

    def _get_export_statuses(self):
        return self.__export_statuses

    def _set_export_statuses(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("export_statuses must be list")
        if value is not None and not all(
            isinstance(i, MessageStreamInfo.exportStatuses) for i in value
        ):
            raise TypeError(
                "export_statuses list values must be MessageStreamInfo.exportStatuses"
            )

        self.__export_statuses = value

    export_statuses = property(_get_export_statuses, _set_export_statuses)

    @staticmethod
    def from_dict(d):
        v = {}
        if "definition" in d:
            v["definition"] = (
                MessageStreamDefinition.from_dict(d["definition"])
                if hasattr(MessageStreamDefinition, "from_dict")
                else d["definition"]
            )
        if "storageStatus" in d:
            v["storage_status"] = (
                MessageStreamInfo.storageStatus.from_dict(d["storageStatus"])
                if hasattr(MessageStreamInfo.storageStatus, "from_dict")
                else d["storageStatus"]
            )
        if "exportStatuses" in d:
            v["export_statuses"] = [
                MessageStreamInfo.exportStatuses.from_dict(p)
                if hasattr(MessageStreamInfo.exportStatuses, "from_dict")
                else p
                for p in d["exportStatuses"]
            ]
        return MessageStreamInfo(**v)

    def as_dict(self):
        d = {}
        if self.__definition is not None:
            d["definition"] = (
                self.__definition.as_dict()
                if hasattr(self.__definition, "as_dict")
                else self.__definition
            )
        if self.__storage_status is not None:
            d["storageStatus"] = (
                self.__storage_status.as_dict()
                if hasattr(self.__storage_status, "as_dict")
                else self.__storage_status
            )
        if self.__export_statuses is not None:
            d["exportStatuses"] = [
                p.as_dict() if hasattr(p, "as_dict") else p
                for p in self.__export_statuses
            ]
        return d

    def __repr__(self):
        return "<Class MessageStreamInfo. definition: {}, storage_status: {}, export_statuses: {}>".format(
            limitedRepr(
                self.__definition[:20]
                if isinstance(self.__definition, bytes)
                else self.__definition
            ),
            limitedRepr(
                self.__storage_status[:20]
                if isinstance(self.__storage_status, bytes)
                else self.__storage_status
            ),
            limitedRepr(
                self.__export_statuses[:20]
                if isinstance(self.__export_statuses, bytes)
                else self.__export_statuses
            ),
        )


class DescribeMessageStreamResponse:
    """
    (Internal Only) Response object for describing a message stream.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
        "__message_stream_info",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
        "message_stream_info": {"type": MessageStreamInfo, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
        "message_stream_info": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
        message_stream_info: MessageStreamInfo = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message
        self.__message_stream_info = message_stream_info

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    def _get_message_stream_info(self):
        return self.__message_stream_info

    def _set_message_stream_info(self, value):
        if value is not None and not isinstance(value, MessageStreamInfo):
            raise TypeError("message_stream_info must be MessageStreamInfo")

        self.__message_stream_info = value

    message_stream_info = property(_get_message_stream_info, _set_message_stream_info)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        if "messageStreamInfo" in d:
            v["message_stream_info"] = (
                MessageStreamInfo.from_dict(d["messageStreamInfo"])
                if hasattr(MessageStreamInfo, "from_dict")
                else d["messageStreamInfo"]
            )
        return DescribeMessageStreamResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        if self.__message_stream_info is not None:
            d["messageStreamInfo"] = (
                self.__message_stream_info.as_dict()
                if hasattr(self.__message_stream_info, "as_dict")
                else self.__message_stream_info
            )
        return d

    def __repr__(self):
        return "<Class DescribeMessageStreamResponse. request_id: {}, status: {}, error_message: {}, message_stream_info: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
            limitedRepr(
                self.__message_stream_info[:20]
                if isinstance(self.__message_stream_info, bytes)
                else self.__message_stream_info
            ),
        )


class AppendMessageRequest:
    """
    (Internal Only) Request object for appending to a message stream.
    """

    __slots__ = [
        "__request_id",
        "__name",
        "__payload",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "name": {"type": str, "subtype": None},
        "payload": {"type": bytes, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "name": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "payload": {
            "required": True,
            "minLength": 1,
        },
    }

    def __init__(self, request_id: str = None, name: str = None, payload: bytes = None):
        pass
        self.__request_id = request_id
        self.__name = name
        self.__payload = payload

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_name(self):
        return self.__name

    def _set_name(self, value):
        if not isinstance(value, str):
            raise TypeError("name must be str")

        self.__name = value

    name = property(_get_name, _set_name)

    def _get_payload(self):
        return self.__payload

    def _set_payload(self, value):
        if not isinstance(value, bytes):
            raise TypeError("payload must be bytes")

        self.__payload = value

    payload = property(_get_payload, _set_payload)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "name" in d:
            v["name"] = (
                str.from_dict(d["name"]) if hasattr(str, "from_dict") else d["name"]
            )
        if "payload" in d:
            v["payload"] = (
                bytes.from_dict(d["payload"])
                if hasattr(bytes, "from_dict")
                else d["payload"]
            )
        return AppendMessageRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__name is not None:
            d["name"] = (
                self.__name.as_dict()
                if hasattr(self.__name, "as_dict")
                else self.__name
            )
        if self.__payload is not None:
            d["payload"] = (
                self.__payload.as_dict()
                if hasattr(self.__payload, "as_dict")
                else self.__payload
            )
        return d

    def __repr__(self):
        return "<Class AppendMessageRequest. request_id: {}, name: {}, payload: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__name[:20] if isinstance(self.__name, bytes) else self.__name
            ),
            limitedRepr(
                self.__payload[:20]
                if isinstance(self.__payload, bytes)
                else self.__payload
            ),
        )


class AppendMessageResponse:
    """
    Internal Only.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
        "__sequence_number",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
        "sequence_number": {"type": int, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
        "sequence_number": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
        sequence_number: int = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message
        self.__sequence_number = sequence_number

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    def _get_sequence_number(self):
        return self.__sequence_number

    def _set_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("sequence_number must be int")

        self.__sequence_number = value

    sequence_number = property(_get_sequence_number, _set_sequence_number)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        if "sequenceNumber" in d:
            v["sequence_number"] = (
                int.from_dict(d["sequenceNumber"])
                if hasattr(int, "from_dict")
                else d["sequenceNumber"]
            )
        return AppendMessageResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        if self.__sequence_number is not None:
            d["sequenceNumber"] = (
                self.__sequence_number.as_dict()
                if hasattr(self.__sequence_number, "as_dict")
                else self.__sequence_number
            )
        return d

    def __repr__(self):
        return "<Class AppendMessageResponse. request_id: {}, status: {}, error_message: {}, sequence_number: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
            limitedRepr(
                self.__sequence_number[:20]
                if isinstance(self.__sequence_number, bytes)
                else self.__sequence_number
            ),
        )


class ReadMessagesOptions:
    """
    Options for the ReadMessages API. All fields are optional.
    """

    __slots__ = [
        "__desired_start_sequence_number",
        "__min_message_count",
        "__max_message_count",
        "__read_timeout_millis",
    ]

    _types_map = {
        "desired_start_sequence_number": {"type": int, "subtype": None},
        "min_message_count": {"type": int, "subtype": None},
        "max_message_count": {"type": int, "subtype": None},
        "read_timeout_millis": {"type": int, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "desired_start_sequence_number": {
            "required": False,
            "maximum": 9223372036854775807,
            "minimum": 0,
        },
        "min_message_count": {
            "required": False,
            "maximum": 2147483647,
            "minimum": 1,
        },
        "max_message_count": {
            "required": False,
            "maximum": 2147483647,
            "minimum": 1,
        },
        "read_timeout_millis": {
            "required": False,
            "maximum": 9223372036854,
            "minimum": 0,
        },
    }

    def __init__(
        self,
        desired_start_sequence_number: int = None,
        min_message_count: int = 1,
        max_message_count: int = None,
        read_timeout_millis: int = 0,
    ):
        """
        :param desired_start_sequence_number: The desired beginning sequence number to start reading from. If the desired sequence number is less than the current minimum of the stream, then it will instead start reading from the current minimum.
        :param min_message_count: The minimum number of messages that will be returned. If not enough messages are available for reading, then NotEnoughMessages exception will be thrown.
            The minimum values is 1 and the maximum value is 2147483647.
        :param max_message_count: The maximum number of messages that will be returned.
            The minimum values is the value of the minimum message count and the maximum value is 2147483647.
        :param read_timeout_millis: The time to wait for messages in milliseconds. Default is 0, meaning that the server will not wait for messages.
            If it can fulfill the minimum messages it will return them, but otherwise NotEnoughMessages exception will be thrown.
            If the timeout is greater than zero, then the server will wait up to that time for more messages to be appended to the stream, waiting until the minimum number of messages is reached.
            The maximum value is the value of the client timeout.
        """
        pass
        self.__desired_start_sequence_number = desired_start_sequence_number
        self.__min_message_count = min_message_count
        self.__max_message_count = max_message_count
        self.__read_timeout_millis = read_timeout_millis

    def _get_desired_start_sequence_number(self):
        return self.__desired_start_sequence_number

    def _set_desired_start_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("desired_start_sequence_number must be int")

        self.__desired_start_sequence_number = value

    desired_start_sequence_number = property(
        _get_desired_start_sequence_number, _set_desired_start_sequence_number
    )
    """
    The desired beginning sequence number to start reading from. If the desired sequence number is less than the current minimum of the stream, then it will instead start reading from the current minimum.
    """

    def _get_min_message_count(self):
        return self.__min_message_count

    def _set_min_message_count(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("min_message_count must be int")

        self.__min_message_count = value

    min_message_count = property(_get_min_message_count, _set_min_message_count)
    """
    The minimum number of messages that will be returned. If not enough messages are available for reading, then NotEnoughMessages exception will be thrown.
    The minimum values is 1 and the maximum value is 2147483647.
    """

    def _get_max_message_count(self):
        return self.__max_message_count

    def _set_max_message_count(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("max_message_count must be int")

        self.__max_message_count = value

    max_message_count = property(_get_max_message_count, _set_max_message_count)
    """
    The maximum number of messages that will be returned.
    The minimum values is the value of the minimum message count and the maximum value is 2147483647.
    """

    def _get_read_timeout_millis(self):
        return self.__read_timeout_millis

    def _set_read_timeout_millis(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("read_timeout_millis must be int")

        self.__read_timeout_millis = value

    read_timeout_millis = property(_get_read_timeout_millis, _set_read_timeout_millis)
    """
    The time to wait for messages in milliseconds. Default is 0, meaning that the server will not wait for messages.
    If it can fulfill the minimum messages it will return them, but otherwise NotEnoughMessages exception will be thrown.
    If the timeout is greater than zero, then the server will wait up to that time for more messages to be appended to the stream, waiting until the minimum number of messages is reached.
    The maximum value is the value of the client timeout.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "desiredStartSequenceNumber" in d:
            v["desired_start_sequence_number"] = (
                int.from_dict(d["desiredStartSequenceNumber"])
                if hasattr(int, "from_dict")
                else d["desiredStartSequenceNumber"]
            )
        if "minMessageCount" in d:
            v["min_message_count"] = (
                int.from_dict(d["minMessageCount"])
                if hasattr(int, "from_dict")
                else d["minMessageCount"]
            )
        if "maxMessageCount" in d:
            v["max_message_count"] = (
                int.from_dict(d["maxMessageCount"])
                if hasattr(int, "from_dict")
                else d["maxMessageCount"]
            )
        if "readTimeoutMillis" in d:
            v["read_timeout_millis"] = (
                int.from_dict(d["readTimeoutMillis"])
                if hasattr(int, "from_dict")
                else d["readTimeoutMillis"]
            )
        return ReadMessagesOptions(**v)

    def as_dict(self):
        d = {}
        if self.__desired_start_sequence_number is not None:
            d["desiredStartSequenceNumber"] = (
                self.__desired_start_sequence_number.as_dict()
                if hasattr(self.__desired_start_sequence_number, "as_dict")
                else self.__desired_start_sequence_number
            )
        if self.__min_message_count is not None:
            d["minMessageCount"] = (
                self.__min_message_count.as_dict()
                if hasattr(self.__min_message_count, "as_dict")
                else self.__min_message_count
            )
        if self.__max_message_count is not None:
            d["maxMessageCount"] = (
                self.__max_message_count.as_dict()
                if hasattr(self.__max_message_count, "as_dict")
                else self.__max_message_count
            )
        if self.__read_timeout_millis is not None:
            d["readTimeoutMillis"] = (
                self.__read_timeout_millis.as_dict()
                if hasattr(self.__read_timeout_millis, "as_dict")
                else self.__read_timeout_millis
            )
        return d

    def __repr__(self):
        return "<Class ReadMessagesOptions. desired_start_sequence_number: {}, min_message_count: {}, max_message_count: {}, read_timeout_millis: {}>".format(
            limitedRepr(
                self.__desired_start_sequence_number[:20]
                if isinstance(self.__desired_start_sequence_number, bytes)
                else self.__desired_start_sequence_number
            ),
            limitedRepr(
                self.__min_message_count[:20]
                if isinstance(self.__min_message_count, bytes)
                else self.__min_message_count
            ),
            limitedRepr(
                self.__max_message_count[:20]
                if isinstance(self.__max_message_count, bytes)
                else self.__max_message_count
            ),
            limitedRepr(
                self.__read_timeout_millis[:20]
                if isinstance(self.__read_timeout_millis, bytes)
                else self.__read_timeout_millis
            ),
        )


class ReadMessagesRequest:
    """
    (Internal Only) Request object for reading from a message stream. readMessagesOptions is optional.
    """

    __slots__ = [
        "__request_id",
        "__stream_name",
        "__read_messages_options",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "stream_name": {"type": str, "subtype": None},
        "read_messages_options": {"type": ReadMessagesOptions, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "stream_name": {
            "required": True,
            "minLength": 1,
            "maxLength": 255,
            "pattern": "^[\w ,.\-_]*$",
        },
        "read_messages_options": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        stream_name: str = None,
        read_messages_options: ReadMessagesOptions = None,
    ):
        pass
        self.__request_id = request_id
        self.__stream_name = stream_name
        self.__read_messages_options = read_messages_options

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_stream_name(self):
        return self.__stream_name

    def _set_stream_name(self, value):
        if not isinstance(value, str):
            raise TypeError("stream_name must be str")

        self.__stream_name = value

    stream_name = property(_get_stream_name, _set_stream_name)

    def _get_read_messages_options(self):
        return self.__read_messages_options

    def _set_read_messages_options(self, value):
        if value is not None and not isinstance(value, ReadMessagesOptions):
            raise TypeError("read_messages_options must be ReadMessagesOptions")

        self.__read_messages_options = value

    read_messages_options = property(
        _get_read_messages_options, _set_read_messages_options
    )

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "streamName" in d:
            v["stream_name"] = (
                str.from_dict(d["streamName"])
                if hasattr(str, "from_dict")
                else d["streamName"]
            )
        if "readMessagesOptions" in d:
            v["read_messages_options"] = (
                ReadMessagesOptions.from_dict(d["readMessagesOptions"])
                if hasattr(ReadMessagesOptions, "from_dict")
                else d["readMessagesOptions"]
            )
        return ReadMessagesRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__stream_name is not None:
            d["streamName"] = (
                self.__stream_name.as_dict()
                if hasattr(self.__stream_name, "as_dict")
                else self.__stream_name
            )
        if self.__read_messages_options is not None:
            d["readMessagesOptions"] = (
                self.__read_messages_options.as_dict()
                if hasattr(self.__read_messages_options, "as_dict")
                else self.__read_messages_options
            )
        return d

    def __repr__(self):
        return "<Class ReadMessagesRequest. request_id: {}, stream_name: {}, read_messages_options: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__stream_name[:20]
                if isinstance(self.__stream_name, bytes)
                else self.__stream_name
            ),
            limitedRepr(
                self.__read_messages_options[:20]
                if isinstance(self.__read_messages_options, bytes)
                else self.__read_messages_options
            ),
        )


class Message:
    """
    Message object containing metadata and the user's payload.
    """

    __slots__ = [
        "__stream_name",
        "__sequence_number",
        "__ingest_time",
        "__payload",
    ]

    _types_map = {
        "stream_name": {"type": str, "subtype": None},
        "sequence_number": {"type": int, "subtype": None},
        "ingest_time": {"type": int, "subtype": None},
        "payload": {"type": bytes, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "stream_name": {
            "required": True,
        },
        "sequence_number": {
            "required": False,
        },
        "ingest_time": {
            "required": False,
        },
        "payload": {
            "required": True,
        },
    }

    def __init__(
        self,
        stream_name: str = None,
        sequence_number: int = None,
        ingest_time: int = None,
        payload: bytes = None,
    ):
        """
        :param stream_name: The name of the stream which this message is in.
        :param sequence_number: The sequence number of this message within the stream.
        :param ingest_time: The time that the message was ingested to Stream Manager. Data is Unix epoch time in milliseconds.
        :param payload: The binary message data.
        """
        pass
        self.__stream_name = stream_name
        self.__sequence_number = sequence_number
        self.__ingest_time = ingest_time
        self.__payload = payload

    def _get_stream_name(self):
        return self.__stream_name

    def _set_stream_name(self, value):
        if not isinstance(value, str):
            raise TypeError("stream_name must be str")

        self.__stream_name = value

    stream_name = property(_get_stream_name, _set_stream_name)
    """
    The name of the stream which this message is in.
    """

    def _get_sequence_number(self):
        return self.__sequence_number

    def _set_sequence_number(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("sequence_number must be int")

        self.__sequence_number = value

    sequence_number = property(_get_sequence_number, _set_sequence_number)
    """
    The sequence number of this message within the stream.
    """

    def _get_ingest_time(self):
        return self.__ingest_time

    def _set_ingest_time(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("ingest_time must be int")

        self.__ingest_time = value

    ingest_time = property(_get_ingest_time, _set_ingest_time)
    """
    The time that the message was ingested to Stream Manager. Data is Unix epoch time in milliseconds.
    """

    def _get_payload(self):
        return self.__payload

    def _set_payload(self, value):
        if not isinstance(value, bytes):
            raise TypeError("payload must be bytes")

        self.__payload = value

    payload = property(_get_payload, _set_payload)
    """
    The binary message data.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "streamName" in d:
            v["stream_name"] = (
                str.from_dict(d["streamName"])
                if hasattr(str, "from_dict")
                else d["streamName"]
            )
        if "sequenceNumber" in d:
            v["sequence_number"] = (
                int.from_dict(d["sequenceNumber"])
                if hasattr(int, "from_dict")
                else d["sequenceNumber"]
            )
        if "ingestTime" in d:
            v["ingest_time"] = (
                int.from_dict(d["ingestTime"])
                if hasattr(int, "from_dict")
                else d["ingestTime"]
            )
        if "payload" in d:
            v["payload"] = (
                bytes.from_dict(d["payload"])
                if hasattr(bytes, "from_dict")
                else d["payload"]
            )
        return Message(**v)

    def as_dict(self):
        d = {}
        if self.__stream_name is not None:
            d["streamName"] = (
                self.__stream_name.as_dict()
                if hasattr(self.__stream_name, "as_dict")
                else self.__stream_name
            )
        if self.__sequence_number is not None:
            d["sequenceNumber"] = (
                self.__sequence_number.as_dict()
                if hasattr(self.__sequence_number, "as_dict")
                else self.__sequence_number
            )
        if self.__ingest_time is not None:
            d["ingestTime"] = (
                self.__ingest_time.as_dict()
                if hasattr(self.__ingest_time, "as_dict")
                else self.__ingest_time
            )
        if self.__payload is not None:
            d["payload"] = (
                self.__payload.as_dict()
                if hasattr(self.__payload, "as_dict")
                else self.__payload
            )
        return d

    def __repr__(self):
        return "<Class Message. stream_name: {}, sequence_number: {}, ingest_time: {}, payload: {}>".format(
            limitedRepr(
                self.__stream_name[:20]
                if isinstance(self.__stream_name, bytes)
                else self.__stream_name
            ),
            limitedRepr(
                self.__sequence_number[:20]
                if isinstance(self.__sequence_number, bytes)
                else self.__sequence_number
            ),
            limitedRepr(
                self.__ingest_time[:20]
                if isinstance(self.__ingest_time, bytes)
                else self.__ingest_time
            ),
            limitedRepr(
                self.__payload[:20]
                if isinstance(self.__payload, bytes)
                else self.__payload
            ),
        )


class ReadMessagesResponse:
    """
    Internal Only.
    """

    __slots__ = [
        "__request_id",
        "__messages",
        "__status",
        "__error_message",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "messages": {"type": list, "subtype": Message},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": False,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "messages": {
            "required": False,
        },
        "status": {
            "required": False,
        },
        "error_message": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        messages: List[Message] = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
    ):
        pass
        self.__request_id = request_id
        self.__messages = messages
        self.__status = status
        self.__error_message = error_message

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_messages(self):
        return self.__messages

    def _set_messages(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("messages must be list")
        if value is not None and not all(isinstance(i, Message) for i in value):
            raise TypeError("messages list values must be Message")

        self.__messages = value

    messages = property(_get_messages, _set_messages)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if value is not None and not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "messages" in d:
            v["messages"] = [
                Message.from_dict(p) if hasattr(Message, "from_dict") else p
                for p in d["messages"]
            ]
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        return ReadMessagesResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__messages is not None:
            d["messages"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__messages
            ]
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        return d

    def __repr__(self):
        return "<Class ReadMessagesResponse. request_id: {}, messages: {}, status: {}, error_message: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__messages[:20]
                if isinstance(self.__messages, bytes)
                else self.__messages
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
        )


class ListStreamsRequest:
    """
    (Internal Only) Request object to list all available streams. There are no options.
    """

    __slots__ = [
        "__request_id",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
    }

    def __init__(self, request_id: str = None):
        pass
        self.__request_id = request_id

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        return ListStreamsRequest(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        return d

    def __repr__(self):
        return "<Class ListStreamsRequest. request_id: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            )
        )


class ListStreamsResponse:
    """
    Internal Only.
    """

    __slots__ = [
        "__request_id",
        "__status",
        "__error_message",
        "__streams",
    ]

    _types_map = {
        "request_id": {"type": str, "subtype": None},
        "status": {"type": ResponseStatusCode, "subtype": None},
        "error_message": {"type": str, "subtype": None},
        "streams": {"type": list, "subtype": str},
    }
    _formats_map = {}
    _validations_map = {
        "request_id": {
            "required": True,
            "minLength": 1,
            "pattern": "^[\w ,.\-_]*$",
        },
        "status": {
            "required": True,
        },
        "error_message": {
            "required": False,
        },
        "streams": {
            "required": False,
        },
    }

    def __init__(
        self,
        request_id: str = None,
        status: ResponseStatusCode = None,
        error_message: str = None,
        streams: List[str] = None,
    ):
        pass
        self.__request_id = request_id
        self.__status = status
        self.__error_message = error_message
        self.__streams = streams

    def _get_request_id(self):
        return self.__request_id

    def _set_request_id(self, value):
        if not isinstance(value, str):
            raise TypeError("request_id must be str")

        self.__request_id = value

    request_id = property(_get_request_id, _set_request_id)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, ResponseStatusCode):
            raise TypeError("status must be ResponseStatusCode")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_error_message(self):
        return self.__error_message

    def _set_error_message(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("error_message must be str")

        self.__error_message = value

    error_message = property(_get_error_message, _set_error_message)

    def _get_streams(self):
        return self.__streams

    def _set_streams(self, value):
        if value is not None and not isinstance(value, list):
            raise TypeError("streams must be list")
        if value is not None and not all(isinstance(i, str) for i in value):
            raise TypeError("streams list values must be str")

        self.__streams = value

    streams = property(_get_streams, _set_streams)

    @staticmethod
    def from_dict(d):
        v = {}
        if "requestId" in d:
            v["request_id"] = (
                str.from_dict(d["requestId"])
                if hasattr(str, "from_dict")
                else d["requestId"]
            )
        if "status" in d:
            v["status"] = (
                ResponseStatusCode.from_dict(d["status"])
                if hasattr(ResponseStatusCode, "from_dict")
                else d["status"]
            )
        if "errorMessage" in d:
            v["error_message"] = (
                str.from_dict(d["errorMessage"])
                if hasattr(str, "from_dict")
                else d["errorMessage"]
            )
        if "streams" in d:
            v["streams"] = [
                str.from_dict(p) if hasattr(str, "from_dict") else p
                for p in d["streams"]
            ]
        return ListStreamsResponse(**v)

    def as_dict(self):
        d = {}
        if self.__request_id is not None:
            d["requestId"] = (
                self.__request_id.as_dict()
                if hasattr(self.__request_id, "as_dict")
                else self.__request_id
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__error_message is not None:
            d["errorMessage"] = (
                self.__error_message.as_dict()
                if hasattr(self.__error_message, "as_dict")
                else self.__error_message
            )
        if self.__streams is not None:
            d["streams"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__streams
            ]
        return d

    def __repr__(self):
        return "<Class ListStreamsResponse. request_id: {}, status: {}, error_message: {}, streams: {}>".format(
            limitedRepr(
                self.__request_id[:20]
                if isinstance(self.__request_id, bytes)
                else self.__request_id
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__error_message[:20]
                if isinstance(self.__error_message, bytes)
                else self.__error_message
            ),
            limitedRepr(
                self.__streams[:20]
                if isinstance(self.__streams, bytes)
                else self.__streams
            ),
        )


class TimeInNanos:
    """
    Contains a timestamp with optional nanosecond granularity.
    """

    __slots__ = [
        "__time_in_seconds",
        "__offset_in_nanos",
    ]

    _types_map = {
        "time_in_seconds": {"type": int, "subtype": None},
        "offset_in_nanos": {"type": int, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "time_in_seconds": {
            "required": True,
            "maximum": 31556889864403199,
            "minimum": 1,
        },
        "offset_in_nanos": {
            "required": False,
            "maximum": 999999999,
            "minimum": 0,
        },
    }

    def __init__(self, time_in_seconds: int = None, offset_in_nanos: int = None):
        """
        :param time_in_seconds: The timestamp date, in seconds, in the Unix epoch format. Fractional nanosecond data is provided by offsetInNanos.
        :param offset_in_nanos: The nanosecond offset from timeInSeconds.
        """
        pass
        self.__time_in_seconds = time_in_seconds
        self.__offset_in_nanos = offset_in_nanos

    def _get_time_in_seconds(self):
        return self.__time_in_seconds

    def _set_time_in_seconds(self, value):
        if not isinstance(value, int):
            raise TypeError("time_in_seconds must be int")

        self.__time_in_seconds = value

    time_in_seconds = property(_get_time_in_seconds, _set_time_in_seconds)
    """
    The timestamp date, in seconds, in the Unix epoch format. Fractional nanosecond data is provided by offsetInNanos.
    """

    def _get_offset_in_nanos(self):
        return self.__offset_in_nanos

    def _set_offset_in_nanos(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("offset_in_nanos must be int")

        self.__offset_in_nanos = value

    offset_in_nanos = property(_get_offset_in_nanos, _set_offset_in_nanos)
    """
    The nanosecond offset from timeInSeconds.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "timeInSeconds" in d:
            v["time_in_seconds"] = (
                int.from_dict(d["timeInSeconds"])
                if hasattr(int, "from_dict")
                else d["timeInSeconds"]
            )
        if "offsetInNanos" in d:
            v["offset_in_nanos"] = (
                int.from_dict(d["offsetInNanos"])
                if hasattr(int, "from_dict")
                else d["offsetInNanos"]
            )
        return TimeInNanos(**v)

    def as_dict(self):
        d = {}
        if self.__time_in_seconds is not None:
            d["timeInSeconds"] = (
                self.__time_in_seconds.as_dict()
                if hasattr(self.__time_in_seconds, "as_dict")
                else self.__time_in_seconds
            )
        if self.__offset_in_nanos is not None:
            d["offsetInNanos"] = (
                self.__offset_in_nanos.as_dict()
                if hasattr(self.__offset_in_nanos, "as_dict")
                else self.__offset_in_nanos
            )
        return d

    def __repr__(self):
        return "<Class TimeInNanos. time_in_seconds: {}, offset_in_nanos: {}>".format(
            limitedRepr(
                self.__time_in_seconds[:20]
                if isinstance(self.__time_in_seconds, bytes)
                else self.__time_in_seconds
            ),
            limitedRepr(
                self.__offset_in_nanos[:20]
                if isinstance(self.__offset_in_nanos, bytes)
                else self.__offset_in_nanos
            ),
        )


class Quality(enum.Enum):

    GOOD = "GOOD"
    BAD = "BAD"
    UNCERTAIN = "UNCERTAIN"

    @staticmethod
    def from_dict(d):
        return Quality(d)

    def as_dict(self):
        return self.value

    def __repr__(self):
        return "<Enum Quality. {}: {}>".format(
            limitedRepr(self.name), limitedRepr(self.value)
        )


class Variant:
    """
    Contains an asset property value (of a single type only).
    """

    __slots__ = [
        "__string_value",
        "__integer_value",
        "__double_value",
        "__boolean_value",
    ]

    _types_map = {
        "string_value": {"type": str, "subtype": None},
        "integer_value": {"type": int, "subtype": None},
        "double_value": {"type": float, "subtype": None},
        "boolean_value": {"type": bool, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "string_value": {
            "required": False,
            "minLength": 1,
            "maxLength": 1024,
            "pattern": "[^\u0000-\u001F\u007F]+",
        },
        "integer_value": {
            "required": False,
            "maximum": 2147483647,
            "minimum": 0,
        },
        "double_value": {
            "required": False,
        },
        "boolean_value": {
            "required": False,
        },
    }

    def __init__(
        self,
        string_value: str = None,
        integer_value: int = None,
        double_value: float = None,
        boolean_value: bool = None,
    ):
        """
        :param string_value: Asset property data of type string (sequence of characters).
        :param integer_value: Asset property data of type integer (whole number).
        :param double_value: Asset property data of type double (floating point number).
        :param boolean_value: Asset property data of type Boolean (true or false).
        """
        pass
        self.__string_value = string_value
        self.__integer_value = integer_value
        self.__double_value = double_value
        self.__boolean_value = boolean_value

    def _get_string_value(self):
        return self.__string_value

    def _set_string_value(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("string_value must be str")

        self.__string_value = value

    string_value = property(_get_string_value, _set_string_value)
    """
    Asset property data of type string (sequence of characters).
    """

    def _get_integer_value(self):
        return self.__integer_value

    def _set_integer_value(self, value):
        if value is not None and not isinstance(value, int):
            raise TypeError("integer_value must be int")

        self.__integer_value = value

    integer_value = property(_get_integer_value, _set_integer_value)
    """
    Asset property data of type integer (whole number).
    """

    def _get_double_value(self):
        return self.__double_value

    def _set_double_value(self, value):
        if value is not None and not isinstance(value, float):
            raise TypeError("double_value must be float")

        self.__double_value = value

    double_value = property(_get_double_value, _set_double_value)
    """
    Asset property data of type double (floating point number).
    """

    def _get_boolean_value(self):
        return self.__boolean_value

    def _set_boolean_value(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("boolean_value must be bool")

        self.__boolean_value = value

    boolean_value = property(_get_boolean_value, _set_boolean_value)
    """
    Asset property data of type Boolean (true or false).
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "stringValue" in d:
            v["string_value"] = (
                str.from_dict(d["stringValue"])
                if hasattr(str, "from_dict")
                else d["stringValue"]
            )
        if "integerValue" in d:
            v["integer_value"] = (
                int.from_dict(d["integerValue"])
                if hasattr(int, "from_dict")
                else d["integerValue"]
            )
        if "doubleValue" in d:
            v["double_value"] = (
                float.from_dict(d["doubleValue"])
                if hasattr(float, "from_dict")
                else d["doubleValue"]
            )
        if "booleanValue" in d:
            v["boolean_value"] = (
                bool.from_dict(d["booleanValue"])
                if hasattr(bool, "from_dict")
                else d["booleanValue"]
            )
        return Variant(**v)

    def as_dict(self):
        d = {}
        if self.__string_value is not None:
            d["stringValue"] = (
                self.__string_value.as_dict()
                if hasattr(self.__string_value, "as_dict")
                else self.__string_value
            )
        if self.__integer_value is not None:
            d["integerValue"] = (
                self.__integer_value.as_dict()
                if hasattr(self.__integer_value, "as_dict")
                else self.__integer_value
            )
        if self.__double_value is not None:
            d["doubleValue"] = (
                self.__double_value.as_dict()
                if hasattr(self.__double_value, "as_dict")
                else self.__double_value
            )
        if self.__boolean_value is not None:
            d["booleanValue"] = (
                self.__boolean_value.as_dict()
                if hasattr(self.__boolean_value, "as_dict")
                else self.__boolean_value
            )
        return d

    def __repr__(self):
        return "<Class Variant. string_value: {}, integer_value: {}, double_value: {}, boolean_value: {}>".format(
            limitedRepr(
                self.__string_value[:20]
                if isinstance(self.__string_value, bytes)
                else self.__string_value
            ),
            limitedRepr(
                self.__integer_value[:20]
                if isinstance(self.__integer_value, bytes)
                else self.__integer_value
            ),
            limitedRepr(
                self.__double_value[:20]
                if isinstance(self.__double_value, bytes)
                else self.__double_value
            ),
            limitedRepr(
                self.__boolean_value[:20]
                if isinstance(self.__boolean_value, bytes)
                else self.__boolean_value
            ),
        )


class AssetPropertyValue:
    """
    Contains asset property value information.
    """

    __slots__ = [
        "__value",
        "__timestamp",
        "__quality",
    ]

    _types_map = {
        "value": {"type": Variant, "subtype": None},
        "timestamp": {"type": TimeInNanos, "subtype": None},
        "quality": {"type": Quality, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "value": {
            "required": True,
        },
        "timestamp": {
            "required": True,
        },
        "quality": {
            "required": False,
        },
    }

    def __init__(
        self,
        value: Variant = None,
        timestamp: TimeInNanos = None,
        quality: Quality = None,
    ):
        """
        :param value: The value of the asset property.
        :param timestamp: The timestamp of the asset property value.
        :param quality: The quality of the asset property value.
        """
        pass
        self.__value = value
        self.__timestamp = timestamp
        self.__quality = quality

    def _get_value(self):
        return self.__value

    def _set_value(self, value):
        if not isinstance(value, Variant):
            raise TypeError("value must be Variant")

        self.__value = value

    value = property(_get_value, _set_value)
    """
    The value of the asset property.
    """

    def _get_timestamp(self):
        return self.__timestamp

    def _set_timestamp(self, value):
        if not isinstance(value, TimeInNanos):
            raise TypeError("timestamp must be TimeInNanos")

        self.__timestamp = value

    timestamp = property(_get_timestamp, _set_timestamp)
    """
    The timestamp of the asset property value.
    """

    def _get_quality(self):
        return self.__quality

    def _set_quality(self, value):
        if value is not None and not isinstance(value, Quality):
            raise TypeError("quality must be Quality")

        self.__quality = value

    quality = property(_get_quality, _set_quality)
    """
    The quality of the asset property value.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "value" in d:
            v["value"] = (
                Variant.from_dict(d["value"])
                if hasattr(Variant, "from_dict")
                else d["value"]
            )
        if "timestamp" in d:
            v["timestamp"] = (
                TimeInNanos.from_dict(d["timestamp"])
                if hasattr(TimeInNanos, "from_dict")
                else d["timestamp"]
            )
        if "quality" in d:
            v["quality"] = (
                Quality.from_dict(d["quality"])
                if hasattr(Quality, "from_dict")
                else d["quality"]
            )
        return AssetPropertyValue(**v)

    def as_dict(self):
        d = {}
        if self.__value is not None:
            d["value"] = (
                self.__value.as_dict()
                if hasattr(self.__value, "as_dict")
                else self.__value
            )
        if self.__timestamp is not None:
            d["timestamp"] = (
                self.__timestamp.as_dict()
                if hasattr(self.__timestamp, "as_dict")
                else self.__timestamp
            )
        if self.__quality is not None:
            d["quality"] = (
                self.__quality.as_dict()
                if hasattr(self.__quality, "as_dict")
                else self.__quality
            )
        return d

    def __repr__(self):
        return (
            "<Class AssetPropertyValue. value: {}, timestamp: {}, quality: {}>".format(
                limitedRepr(
                    self.__value[:20]
                    if isinstance(self.__value, bytes)
                    else self.__value
                ),
                limitedRepr(
                    self.__timestamp[:20]
                    if isinstance(self.__timestamp, bytes)
                    else self.__timestamp
                ),
                limitedRepr(
                    self.__quality[:20]
                    if isinstance(self.__quality, bytes)
                    else self.__quality
                ),
            )
        )


class PutAssetPropertyValueEntry:
    """
    Contains a list of value updates for a IoTSiteWise asset property in the list of asset entries consumed by the BatchPutAssetPropertyValue API. See https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html.
    """

    __slots__ = [
        "__entry_id",
        "__asset_id",
        "__property_id",
        "__property_alias",
        "__property_values",
    ]

    _types_map = {
        "entry_id": {"type": str, "subtype": None},
        "asset_id": {"type": str, "subtype": None},
        "property_id": {"type": str, "subtype": None},
        "property_alias": {"type": str, "subtype": None},
        "property_values": {"type": list, "subtype": AssetPropertyValue},
    }
    _formats_map = {}
    _validations_map = {
        "entry_id": {
            "required": True,
            "minLength": 1,
            "maxLength": 64,
            "pattern": "^[a-zA-Z0-9_-]+$",
        },
        "asset_id": {
            "required": False,
        },
        "property_id": {
            "required": False,
        },
        "property_alias": {
            "required": False,
            "minLength": 1,
            "maxLength": 2048,
            "pattern": "[^\u0000-\u001F\u007F]+",
        },
        "property_values": {
            "required": True,
            "maxItems": 10,
            "minItems": 1,
        },
    }

    def __init__(
        self,
        entry_id: str = None,
        asset_id: str = None,
        property_id: str = None,
        property_alias: str = None,
        property_values: List[AssetPropertyValue] = None,
    ):
        """
        :param entry_id: The user specified ID for the entry. You can use this ID to identify which entries failed.
        :param asset_id: The ID of the asset to update.
        :param property_id: The ID of the asset property for this entry.
        :param property_alias: The property alias that identifies the property, such as an OPC-UA server data stream path (for example, /company/windfarm/3/turbine/7/temperature). For more information, see https://docs.aws.amazon.com/iot-sitewise/latest/userguide/connect-data-streams.html.
        :param property_values: The list of property values to upload. You can specify up to 10 values.
        """
        pass
        self.__entry_id = entry_id
        self.__asset_id = asset_id
        self.__property_id = property_id
        self.__property_alias = property_alias
        self.__property_values = property_values

    def _get_entry_id(self):
        return self.__entry_id

    def _set_entry_id(self, value):
        if not isinstance(value, str):
            raise TypeError("entry_id must be str")

        self.__entry_id = value

    entry_id = property(_get_entry_id, _set_entry_id)
    """
    The user specified ID for the entry. You can use this ID to identify which entries failed.
    """

    def _get_asset_id(self):
        return self.__asset_id

    def _set_asset_id(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("asset_id must be str")

        self.__asset_id = value

    asset_id = property(_get_asset_id, _set_asset_id)
    """
    The ID of the asset to update.
    """

    def _get_property_id(self):
        return self.__property_id

    def _set_property_id(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("property_id must be str")

        self.__property_id = value

    property_id = property(_get_property_id, _set_property_id)
    """
    The ID of the asset property for this entry.
    """

    def _get_property_alias(self):
        return self.__property_alias

    def _set_property_alias(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("property_alias must be str")

        self.__property_alias = value

    property_alias = property(_get_property_alias, _set_property_alias)
    """
    The property alias that identifies the property, such as an OPC-UA server data stream path (for example, /company/windfarm/3/turbine/7/temperature). For more information, see https://docs.aws.amazon.com/iot-sitewise/latest/userguide/connect-data-streams.html.
    """

    def _get_property_values(self):
        return self.__property_values

    def _set_property_values(self, value):
        if not isinstance(value, list):
            raise TypeError("property_values must be list")
        if not all(isinstance(i, AssetPropertyValue) for i in value):
            raise TypeError("property_values list values must be AssetPropertyValue")

        self.__property_values = value

    property_values = property(_get_property_values, _set_property_values)
    """
    The list of property values to upload. You can specify up to 10 values.
    """

    @staticmethod
    def from_dict(d):
        v = {}
        if "entryId" in d:
            v["entry_id"] = (
                str.from_dict(d["entryId"])
                if hasattr(str, "from_dict")
                else d["entryId"]
            )
        if "assetId" in d:
            v["asset_id"] = (
                str.from_dict(d["assetId"])
                if hasattr(str, "from_dict")
                else d["assetId"]
            )
        if "propertyId" in d:
            v["property_id"] = (
                str.from_dict(d["propertyId"])
                if hasattr(str, "from_dict")
                else d["propertyId"]
            )
        if "propertyAlias" in d:
            v["property_alias"] = (
                str.from_dict(d["propertyAlias"])
                if hasattr(str, "from_dict")
                else d["propertyAlias"]
            )
        if "propertyValues" in d:
            v["property_values"] = [
                AssetPropertyValue.from_dict(p)
                if hasattr(AssetPropertyValue, "from_dict")
                else p
                for p in d["propertyValues"]
            ]
        return PutAssetPropertyValueEntry(**v)

    def as_dict(self):
        d = {}
        if self.__entry_id is not None:
            d["entryId"] = (
                self.__entry_id.as_dict()
                if hasattr(self.__entry_id, "as_dict")
                else self.__entry_id
            )
        if self.__asset_id is not None:
            d["assetId"] = (
                self.__asset_id.as_dict()
                if hasattr(self.__asset_id, "as_dict")
                else self.__asset_id
            )
        if self.__property_id is not None:
            d["propertyId"] = (
                self.__property_id.as_dict()
                if hasattr(self.__property_id, "as_dict")
                else self.__property_id
            )
        if self.__property_alias is not None:
            d["propertyAlias"] = (
                self.__property_alias.as_dict()
                if hasattr(self.__property_alias, "as_dict")
                else self.__property_alias
            )
        if self.__property_values is not None:
            d["propertyValues"] = [
                p.as_dict() if hasattr(p, "as_dict") else p
                for p in self.__property_values
            ]
        return d

    def __repr__(self):
        return "<Class PutAssetPropertyValueEntry. entry_id: {}, asset_id: {}, property_id: {}, property_alias: {}, property_values: {}>".format(
            limitedRepr(
                self.__entry_id[:20]
                if isinstance(self.__entry_id, bytes)
                else self.__entry_id
            ),
            limitedRepr(
                self.__asset_id[:20]
                if isinstance(self.__asset_id, bytes)
                else self.__asset_id
            ),
            limitedRepr(
                self.__property_id[:20]
                if isinstance(self.__property_id, bytes)
                else self.__property_id
            ),
            limitedRepr(
                self.__property_alias[:20]
                if isinstance(self.__property_alias, bytes)
                else self.__property_alias
            ),
            limitedRepr(
                self.__property_values[:20]
                if isinstance(self.__property_values, bytes)
                else self.__property_values
            ),
        )
