#!/usr/bin/env python
# -*- coding: utf-8 -*-

#
# Generated Thu Feb 29 18:07:09 2024 by generateDS.py version 2.43.3.
# Python 3.11.3 (main, Apr 19 2023, 18:49:55) [Clang 14.0.6 ]
#
# Command line options:
#   ('-f', '')
#   ('-o', 'schema/partner_lib.py')
#   ('-s', 'schema/partner.py')
#
# Command line arguments:
#   definitions/PARTNER_SHOP_.xsd
#
# Command line:
#   /Users/daniilossinkin/anaconda3/bin/generateDS -f -o "schema/partner_lib.py" -s "schema/partner.py" definitions/PARTNER_SHOP_.xsd
#
# Current working directory (os.getcwd()):
#   imports
#

import sys
try:
    ModulenotfoundExp_ = ModuleNotFoundError
except NameError:
    ModulenotfoundExp_ = ImportError
from six.moves import zip_longest
import os
import re as re_
import base64
import datetime as datetime_
import decimal as decimal_
from lxml import etree as etree_


Validate_simpletypes_ = True
SaveElementTreeNode = True
TagNamePrefix = ""
if sys.version_info.major == 2:
    BaseStrType_ = basestring
else:
    BaseStrType_ = str


def parsexml_(infile, parser=None, **kwargs):
    if parser is None:
        # Use the lxml ElementTree compatible parser so that, e.g.,
        #   we ignore comments.
        try:
            parser = etree_.ETCompatXMLParser()
        except AttributeError:
            # fallback to xml.etree
            parser = etree_.XMLParser()
    try:
        if isinstance(infile, os.PathLike):
            infile = os.path.join(infile)
    except AttributeError:
        pass
    doc = etree_.parse(infile, parser=parser, **kwargs)
    return doc

def parsexmlstring_(instring, parser=None, **kwargs):
    if parser is None:
        # Use the lxml ElementTree compatible parser so that, e.g.,
        #   we ignore comments.
        try:
            parser = etree_.ETCompatXMLParser()
        except AttributeError:
            # fallback to xml.etree
            parser = etree_.XMLParser()
    element = etree_.fromstring(instring, parser=parser, **kwargs)
    return element

#
# Namespace prefix definition table (and other attributes, too)
#
# The module generatedsnamespaces, if it is importable, must contain
# a dictionary named GeneratedsNamespaceDefs.  This Python dictionary
# should map element type names (strings) to XML schema namespace prefix
# definitions.  The export method for any class for which there is
# a namespace prefix definition, will export that definition in the
# XML representation of that element.  See the export method of
# any generated element type class for an example of the use of this
# table.
# A sample table is:
#
#     # File: generatedsnamespaces.py
#
#     GenerateDSNamespaceDefs = {
#         "ElementtypeA": "http://www.xxx.com/namespaceA",
#         "ElementtypeB": "http://www.xxx.com/namespaceB",
#     }
#
# Additionally, the generatedsnamespaces module can contain a python
# dictionary named GenerateDSNamespaceTypePrefixes that associates element
# types with the namespace prefixes that are to be added to the
# "xsi:type" attribute value.  See the _exportAttributes method of
# any generated element type and the generation of "xsi:type" for an
# example of the use of this table.
# An example table:
#
#     # File: generatedsnamespaces.py
#
#     GenerateDSNamespaceTypePrefixes = {
#         "ElementtypeC": "aaa:",
#         "ElementtypeD": "bbb:",
#     }
#

try:
    from generatedsnamespaces import GenerateDSNamespaceDefs as GenerateDSNamespaceDefs_
except ModulenotfoundExp_ :
    GenerateDSNamespaceDefs_ = {}
try:
    from generatedsnamespaces import GenerateDSNamespaceTypePrefixes as GenerateDSNamespaceTypePrefixes_
except ModulenotfoundExp_ :
    GenerateDSNamespaceTypePrefixes_ = {}

#
# You can replace the following class definition by defining an
# importable module named "generatedscollector" containing a class
# named "GdsCollector".  See the default class definition below for
# clues about the possible content of that class.
#
try:
    from generatedscollector import GdsCollector as GdsCollector_
except ModulenotfoundExp_ :

    class GdsCollector_(object):

        def __init__(self, messages=None):
            if messages is None:
                self.messages = []
            else:
                self.messages = messages

        def add_message(self, msg):
            self.messages.append(msg)

        def get_messages(self):
            return self.messages

        def clear_messages(self):
            self.messages = []

        def print_messages(self):
            for msg in self.messages:
                print("Warning: {}".format(msg))

        def write_messages(self, outstream):
            for msg in self.messages:
                outstream.write("Warning: {}\n".format(msg))


#
# The super-class for enum types
#

try:
    from enum import Enum
except ModulenotfoundExp_ :
    Enum = object

#
# The root super-class for element type classes
#
# Calls to the methods in these classes are generated by generateDS.py.
# You can replace these methods by re-implementing the following class
#   in a module named generatedssuper.py.

try:
    from generatedssuper import GeneratedsSuper
except ModulenotfoundExp_ as exp:
    try:
        from generatedssupersuper import GeneratedsSuperSuper
    except ModulenotfoundExp_ as exp:
        class GeneratedsSuperSuper(object):
            pass
    
    class GeneratedsSuper(GeneratedsSuperSuper):
        __hash__ = object.__hash__
        tzoff_pattern = re_.compile(r'(\+|-)((0\d|1[0-3]):[0-5]\d|14:00)$')
        class _FixedOffsetTZ(datetime_.tzinfo):
            def __init__(self, offset, name):
                self.__offset = datetime_.timedelta(minutes=offset)
                self.__name = name
            def utcoffset(self, dt):
                return self.__offset
            def tzname(self, dt):
                return self.__name
            def dst(self, dt):
                return None
        def __str__(self):
            settings = {
                'str_pretty_print': True,
                'str_indent_level': 0,
                'str_namespaceprefix': '',
                'str_name': self.__class__.__name__,
                'str_namespacedefs': '',
            }
            for n in settings:
                if hasattr(self, n):
                    settings[n] = getattr(self, n)
            if sys.version_info.major == 2:
                from StringIO import StringIO
            else:
                from io import StringIO
            output = StringIO()
            self.export(
                output,
                settings['str_indent_level'],
                pretty_print=settings['str_pretty_print'],
                namespaceprefix_=settings['str_namespaceprefix'],
                name_=settings['str_name'],
                namespacedef_=settings['str_namespacedefs']
            )
            strval = output.getvalue()
            output.close()
            return strval
        def gds_format_string(self, input_data, input_name=''):
            return input_data
        def gds_parse_string(self, input_data, node=None, input_name=''):
            return input_data
        def gds_validate_string(self, input_data, node=None, input_name=''):
            if not input_data:
                return ''
            else:
                return input_data
        def gds_format_base64(self, input_data, input_name=''):
            return base64.b64encode(input_data).decode('ascii')
        def gds_validate_base64(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_integer(self, input_data, input_name=''):
            return '%d' % int(input_data)
        def gds_parse_integer(self, input_data, node=None, input_name=''):
            try:
                ival = int(input_data)
            except (TypeError, ValueError) as exp:
                raise_parse_error(node, 'Requires integer value: %s' % exp)
            return ival
        def gds_validate_integer(self, input_data, node=None, input_name=''):
            try:
                value = int(input_data)
            except (TypeError, ValueError):
                raise_parse_error(node, 'Requires integer value')
            return value
        def gds_format_integer_list(self, input_data, input_name=''):
            if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_):
                input_data = [str(s) for s in input_data]
            return '%s' % ' '.join(input_data)
        def gds_validate_integer_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    int(value)
                except (TypeError, ValueError):
                    raise_parse_error(node, 'Requires sequence of integer values')
            return values
        def gds_format_float(self, input_data, input_name=''):
            value = ('%.15f' % float(input_data)).rstrip('0')
            if value.endswith('.'):
                value += '0'
            return value
    
        def gds_parse_float(self, input_data, node=None, input_name=''):
            try:
                fval_ = float(input_data)
            except (TypeError, ValueError) as exp:
                raise_parse_error(node, 'Requires float or double value: %s' % exp)
            return fval_
        def gds_validate_float(self, input_data, node=None, input_name=''):
            try:
                value = float(input_data)
            except (TypeError, ValueError):
                raise_parse_error(node, 'Requires float value')
            return value
        def gds_format_float_list(self, input_data, input_name=''):
            if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_):
                input_data = [str(s) for s in input_data]
            return '%s' % ' '.join(input_data)
        def gds_validate_float_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    float(value)
                except (TypeError, ValueError):
                    raise_parse_error(node, 'Requires sequence of float values')
            return values
        def gds_format_decimal(self, input_data, input_name=''):
            return_value = '%s' % input_data
            if '.' in return_value:
                return_value = return_value.rstrip('0')
                if return_value.endswith('.'):
                    return_value = return_value.rstrip('.')
            return return_value
        def gds_parse_decimal(self, input_data, node=None, input_name=''):
            try:
                decimal_value = decimal_.Decimal(input_data)
            except (TypeError, ValueError):
                raise_parse_error(node, 'Requires decimal value')
            return decimal_value
        def gds_validate_decimal(self, input_data, node=None, input_name=''):
            try:
                value = decimal_.Decimal(input_data)
            except (TypeError, ValueError):
                raise_parse_error(node, 'Requires decimal value')
            return value
        def gds_format_decimal_list(self, input_data, input_name=''):
            if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_):
                input_data = [str(s) for s in input_data]
            return ' '.join([self.gds_format_decimal(item) for item in input_data])
        def gds_validate_decimal_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    decimal_.Decimal(value)
                except (TypeError, ValueError):
                    raise_parse_error(node, 'Requires sequence of decimal values')
            return values
        def gds_format_double(self, input_data, input_name=''):
            return '%s' % input_data
        def gds_parse_double(self, input_data, node=None, input_name=''):
            try:
                fval_ = float(input_data)
            except (TypeError, ValueError) as exp:
                raise_parse_error(node, 'Requires double or float value: %s' % exp)
            return fval_
        def gds_validate_double(self, input_data, node=None, input_name=''):
            try:
                value = float(input_data)
            except (TypeError, ValueError):
                raise_parse_error(node, 'Requires double or float value')
            return value
        def gds_format_double_list(self, input_data, input_name=''):
            if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_):
                input_data = [str(s) for s in input_data]
            return '%s' % ' '.join(input_data)
        def gds_validate_double_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                try:
                    float(value)
                except (TypeError, ValueError):
                    raise_parse_error(
                        node, 'Requires sequence of double or float values')
            return values
        def gds_format_boolean(self, input_data, input_name=''):
            return ('%s' % input_data).lower()
        def gds_parse_boolean(self, input_data, node=None, input_name=''):
            input_data = input_data.strip()
            if input_data in ('true', '1'):
                bval = True
            elif input_data in ('false', '0'):
                bval = False
            else:
                raise_parse_error(node, 'Requires boolean value')
            return bval
        def gds_validate_boolean(self, input_data, node=None, input_name=''):
            if input_data not in (True, 1, False, 0, ):
                raise_parse_error(
                    node,
                    'Requires boolean value '
                    '(one of True, 1, False, 0)')
            return input_data
        def gds_format_boolean_list(self, input_data, input_name=''):
            if len(input_data) > 0 and not isinstance(input_data[0], BaseStrType_):
                input_data = [str(s) for s in input_data]
            return '%s' % ' '.join(input_data)
        def gds_validate_boolean_list(
                self, input_data, node=None, input_name=''):
            values = input_data.split()
            for value in values:
                value = self.gds_parse_boolean(value, node, input_name)
                if value not in (True, 1, False, 0, ):
                    raise_parse_error(
                        node,
                        'Requires sequence of boolean values '
                        '(one of True, 1, False, 0)')
            return values
        def gds_validate_datetime(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_datetime(self, input_data, input_name=''):
            if input_data.microsecond == 0:
                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d' % (
                    input_data.year,
                    input_data.month,
                    input_data.day,
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                )
            else:
                _svalue = '%04d-%02d-%02dT%02d:%02d:%02d.%s' % (
                    input_data.year,
                    input_data.month,
                    input_data.day,
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
                )
            if input_data.tzinfo is not None:
                tzoff = input_data.tzinfo.utcoffset(input_data)
                if tzoff is not None:
                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
                    if total_seconds == 0:
                        _svalue += 'Z'
                    else:
                        if total_seconds < 0:
                            _svalue += '-'
                            total_seconds *= -1
                        else:
                            _svalue += '+'
                        hours = total_seconds // 3600
                        minutes = (total_seconds - (hours * 3600)) // 60
                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
            return _svalue
        @classmethod
        def gds_parse_datetime(cls, input_data):
            tz = None
            if input_data[-1] == 'Z':
                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
                input_data = input_data[:-1]
            else:
                results = GeneratedsSuper.tzoff_pattern.search(input_data)
                if results is not None:
                    tzoff_parts = results.group(2).split(':')
                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                    if results.group(1) == '-':
                        tzoff *= -1
                    tz = GeneratedsSuper._FixedOffsetTZ(
                        tzoff, results.group(0))
                    input_data = input_data[:-6]
            time_parts = input_data.split('.')
            if len(time_parts) > 1:
                micro_seconds = int(float('0.' + time_parts[1]) * 1000000)
                input_data = '%s.%s' % (
                    time_parts[0], "{}".format(micro_seconds).rjust(6, "0"), )
                dt = datetime_.datetime.strptime(
                    input_data, '%Y-%m-%dT%H:%M:%S.%f')
            else:
                dt = datetime_.datetime.strptime(
                    input_data, '%Y-%m-%dT%H:%M:%S')
            dt = dt.replace(tzinfo=tz)
            return dt
        def gds_validate_date(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_date(self, input_data, input_name=''):
            _svalue = '%04d-%02d-%02d' % (
                input_data.year,
                input_data.month,
                input_data.day,
            )
            try:
                if input_data.tzinfo is not None:
                    tzoff = input_data.tzinfo.utcoffset(input_data)
                    if tzoff is not None:
                        total_seconds = tzoff.seconds + (86400 * tzoff.days)
                        if total_seconds == 0:
                            _svalue += 'Z'
                        else:
                            if total_seconds < 0:
                                _svalue += '-'
                                total_seconds *= -1
                            else:
                                _svalue += '+'
                            hours = total_seconds // 3600
                            minutes = (total_seconds - (hours * 3600)) // 60
                            _svalue += '{0:02d}:{1:02d}'.format(
                                hours, minutes)
            except AttributeError:
                pass
            return _svalue
        @classmethod
        def gds_parse_date(cls, input_data):
            tz = None
            if input_data[-1] == 'Z':
                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
                input_data = input_data[:-1]
            else:
                results = GeneratedsSuper.tzoff_pattern.search(input_data)
                if results is not None:
                    tzoff_parts = results.group(2).split(':')
                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                    if results.group(1) == '-':
                        tzoff *= -1
                    tz = GeneratedsSuper._FixedOffsetTZ(
                        tzoff, results.group(0))
                    input_data = input_data[:-6]
            dt = datetime_.datetime.strptime(input_data, '%Y-%m-%d')
            dt = dt.replace(tzinfo=tz)
            return dt.date()
        def gds_validate_time(self, input_data, node=None, input_name=''):
            return input_data
        def gds_format_time(self, input_data, input_name=''):
            if input_data.microsecond == 0:
                _svalue = '%02d:%02d:%02d' % (
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                )
            else:
                _svalue = '%02d:%02d:%02d.%s' % (
                    input_data.hour,
                    input_data.minute,
                    input_data.second,
                    ('%f' % (float(input_data.microsecond) / 1000000))[2:],
                )
            if input_data.tzinfo is not None:
                tzoff = input_data.tzinfo.utcoffset(input_data)
                if tzoff is not None:
                    total_seconds = tzoff.seconds + (86400 * tzoff.days)
                    if total_seconds == 0:
                        _svalue += 'Z'
                    else:
                        if total_seconds < 0:
                            _svalue += '-'
                            total_seconds *= -1
                        else:
                            _svalue += '+'
                        hours = total_seconds // 3600
                        minutes = (total_seconds - (hours * 3600)) // 60
                        _svalue += '{0:02d}:{1:02d}'.format(hours, minutes)
            return _svalue
        def gds_validate_simple_patterns(self, patterns, target):
            # pat is a list of lists of strings/patterns.
            # The target value must match at least one of the patterns
            # in order for the test to succeed.
            found1 = True
            target = str(target)
            for patterns1 in patterns:
                found2 = False
                for patterns2 in patterns1:
                    mo = re_.search(patterns2, target)
                    if mo is not None and len(mo.group(0)) == len(target):
                        found2 = True
                        break
                if not found2:
                    found1 = False
                    break
            return found1
        @classmethod
        def gds_parse_time(cls, input_data):
            tz = None
            if input_data[-1] == 'Z':
                tz = GeneratedsSuper._FixedOffsetTZ(0, 'UTC')
                input_data = input_data[:-1]
            else:
                results = GeneratedsSuper.tzoff_pattern.search(input_data)
                if results is not None:
                    tzoff_parts = results.group(2).split(':')
                    tzoff = int(tzoff_parts[0]) * 60 + int(tzoff_parts[1])
                    if results.group(1) == '-':
                        tzoff *= -1
                    tz = GeneratedsSuper._FixedOffsetTZ(
                        tzoff, results.group(0))
                    input_data = input_data[:-6]
            if len(input_data.split('.')) > 1:
                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S.%f')
            else:
                dt = datetime_.datetime.strptime(input_data, '%H:%M:%S')
            dt = dt.replace(tzinfo=tz)
            return dt.time()
        def gds_check_cardinality_(
                self, value, input_name,
                min_occurs=0, max_occurs=1, required=None):
            if value is None:
                length = 0
            elif isinstance(value, list):
                length = len(value)
            else:
                length = 1
            if required is not None :
                if required and length < 1:
                    self.gds_collector_.add_message(
                        "Required value {}{} is missing".format(
                            input_name, self.gds_get_node_lineno_()))
            if length < min_occurs:
                self.gds_collector_.add_message(
                    "Number of values for {}{} is below "
                    "the minimum allowed, "
                    "expected at least {}, found {}".format(
                        input_name, self.gds_get_node_lineno_(),
                        min_occurs, length))
            elif length > max_occurs:
                self.gds_collector_.add_message(
                    "Number of values for {}{} is above "
                    "the maximum allowed, "
                    "expected at most {}, found {}".format(
                        input_name, self.gds_get_node_lineno_(),
                        max_occurs, length))
        def gds_validate_builtin_ST_(
                self, validator, value, input_name,
                min_occurs=None, max_occurs=None, required=None):
            if value is not None:
                try:
                    validator(value, input_name=input_name)
                except GDSParseError as parse_error:
                    self.gds_collector_.add_message(str(parse_error))
        def gds_validate_defined_ST_(
                self, validator, value, input_name,
                min_occurs=None, max_occurs=None, required=None):
            if value is not None:
                try:
                    validator(value)
                except GDSParseError as parse_error:
                    self.gds_collector_.add_message(str(parse_error))
        def gds_str_lower(self, instring):
            return instring.lower()
        def get_path_(self, node):
            path_list = []
            self.get_path_list_(node, path_list)
            path_list.reverse()
            path = '/'.join(path_list)
            return path
        Tag_strip_pattern_ = re_.compile(r'\{.*\}')
        def get_path_list_(self, node, path_list):
            if node is None:
                return
            tag = GeneratedsSuper.Tag_strip_pattern_.sub('', node.tag)
            if tag:
                path_list.append(tag)
            self.get_path_list_(node.getparent(), path_list)
        def get_class_obj_(self, node, default_class=None):
            class_obj1 = default_class
            if 'xsi' in node.nsmap:
                classname = node.get('{%s}type' % node.nsmap['xsi'])
                if classname is not None:
                    names = classname.split(':')
                    if len(names) == 2:
                        classname = names[1]
                    class_obj2 = globals().get(classname)
                    if class_obj2 is not None:
                        class_obj1 = class_obj2
            return class_obj1
        def gds_build_any(self, node, type_name=None):
            # provide default value in case option --disable-xml is used.
            content = ""
            content = etree_.tostring(node, encoding="unicode")
            return content
        @classmethod
        def gds_reverse_node_mapping(cls, mapping):
            return dict(((v, k) for k, v in mapping.items()))
        @staticmethod
        def gds_encode(instring):
            if sys.version_info.major == 2:
                if ExternalEncoding:
                    encoding = ExternalEncoding
                else:
                    encoding = 'utf-8'
                return instring.encode(encoding)
            else:
                return instring
        @staticmethod
        def convert_unicode(instring):
            if isinstance(instring, str):
                result = quote_xml(instring)
            elif sys.version_info.major == 2 and isinstance(instring, unicode):
                result = quote_xml(instring).encode('utf8')
            else:
                result = GeneratedsSuper.gds_encode(str(instring))
            return result
        def __eq__(self, other):
            def excl_select_objs_(obj):
                return (obj[0] != 'parent_object_' and
                        obj[0] != 'gds_collector_')
            if type(self) != type(other):
                return False
            return all(x == y for x, y in zip_longest(
                filter(excl_select_objs_, self.__dict__.items()),
                filter(excl_select_objs_, other.__dict__.items())))
        def __ne__(self, other):
            return not self.__eq__(other)
        # Django ETL transform hooks.
        def gds_djo_etl_transform(self):
            pass
        def gds_djo_etl_transform_db_obj(self, dbobj):
            pass
        # SQLAlchemy ETL transform hooks.
        def gds_sqa_etl_transform(self):
            return 0, None
        def gds_sqa_etl_transform_db_obj(self, dbobj):
            pass
        def gds_get_node_lineno_(self):
            if (hasattr(self, "gds_elementtree_node_") and
                    self.gds_elementtree_node_ is not None):
                return ' near line {}'.format(
                    self.gds_elementtree_node_.sourceline)
            else:
                return ""
    
    
    def getSubclassFromModule_(module, class_):
        '''Get the subclass of a class from a specific module.'''
        name = class_.__name__ + 'Sub'
        if hasattr(module, name):
            return getattr(module, name)
        else:
            return None


#
# If you have installed IPython you can uncomment and use the following.
# IPython is available from http://ipython.scipy.org/.
#

## from IPython.Shell import IPShellEmbed
## args = ''
## ipshell = IPShellEmbed(args,
##     banner = 'Dropping into IPython',
##     exit_msg = 'Leaving Interpreter, back to program.')

# Then use the following line where and when you want to drop into the
# IPython shell:
#    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')

#
# Globals
#

ExternalEncoding = ''
# Set this to false in order to deactivate during export, the use of
# name space prefixes captured from the input document.
UseCapturedNS_ = True
CapturedNsmap_ = {}
Tag_pattern_ = re_.compile(r'({.*})?(.*)')
String_cleanup_pat_ = re_.compile(r"[\n\r\s]+")
Namespace_extract_pat_ = re_.compile(r'{(.*)}(.*)')
CDATA_pattern_ = re_.compile(r"<!\[CDATA\[.*?\]\]>", re_.DOTALL)

# Change this to redirect the generated superclass module to use a
# specific subclass module.
CurrentSubclassModule_ = None

#
# Support/utility functions.
#


def showIndent(outfile, level, pretty_print=True):
    if pretty_print:
        for idx in range(level):
            outfile.write('    ')


def quote_xml(inStr):
    "Escape markup chars, but do not modify CDATA sections."
    if not inStr:
        return ''
    s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr)
    s2 = ''
    pos = 0
    matchobjects = CDATA_pattern_.finditer(s1)
    for mo in matchobjects:
        s3 = s1[pos:mo.start()]
        s2 += quote_xml_aux(s3)
        s2 += s1[mo.start():mo.end()]
        pos = mo.end()
    s3 = s1[pos:]
    s2 += quote_xml_aux(s3)
    return s2


def quote_xml_aux(inStr):
    s1 = inStr.replace('&', '&amp;')
    s1 = s1.replace('<', '&lt;')
    s1 = s1.replace('>', '&gt;')
    return s1


def quote_attrib(inStr):
    s1 = (isinstance(inStr, BaseStrType_) and inStr or '%s' % inStr)
    s1 = s1.replace('&', '&amp;')
    s1 = s1.replace('<', '&lt;')
    s1 = s1.replace('>', '&gt;')
    s1 = s1.replace('\n', '&#10;')
    if '"' in s1:
        if "'" in s1:
            s1 = '"%s"' % s1.replace('"', "&quot;")
        else:
            s1 = "'%s'" % s1
    else:
        s1 = '"%s"' % s1
    return s1


def quote_python(inStr):
    s1 = inStr
    if s1.find("'") == -1:
        if s1.find('\n') == -1:
            return "'%s'" % s1
        else:
            return "'''%s'''" % s1
    else:
        if s1.find('"') != -1:
            s1 = s1.replace('"', '\\"')
        if s1.find('\n') == -1:
            return '"%s"' % s1
        else:
            return '"""%s"""' % s1


def get_all_text_(node):
    if node.text is not None:
        text = node.text
    else:
        text = ''
    for child in node:
        if child.tail is not None:
            text += child.tail
    return text


def find_attr_value_(attr_name, node):
    attrs = node.attrib
    attr_parts = attr_name.split(':')
    value = None
    if len(attr_parts) == 1:
        value = attrs.get(attr_name)
    elif len(attr_parts) == 2:
        prefix, name = attr_parts
        if prefix == 'xml':
            namespace = 'http://www.w3.org/XML/1998/namespace'
        else:
            namespace = node.nsmap.get(prefix)
        if namespace is not None:
            value = attrs.get('{%s}%s' % (namespace, name, ))
    return value


def encode_str_2_3(instr):
    return instr


class GDSParseError(Exception):
    pass


def raise_parse_error(node, msg):
    if node is not None:
        msg = '%s (element %s/line %d)' % (msg, node.tag, node.sourceline, )
    raise GDSParseError(msg)


class MixedContainer:
    # Constants for category:
    CategoryNone = 0
    CategoryText = 1
    CategorySimple = 2
    CategoryComplex = 3
    # Constants for content_type:
    TypeNone = 0
    TypeText = 1
    TypeString = 2
    TypeInteger = 3
    TypeFloat = 4
    TypeDecimal = 5
    TypeDouble = 6
    TypeBoolean = 7
    TypeBase64 = 8
    def __init__(self, category, content_type, name, value):
        self.category = category
        self.content_type = content_type
        self.name = name
        self.value = value
    def getCategory(self):
        return self.category
    def getContenttype(self, content_type):
        return self.content_type
    def getValue(self):
        return self.value
    def getName(self):
        return self.name
    def export(self, outfile, level, name, namespace,
               pretty_print=True):
        if self.category == MixedContainer.CategoryText:
            # Prevent exporting empty content as empty lines.
            if self.value.strip():
                outfile.write(self.value)
        elif self.category == MixedContainer.CategorySimple:
            self.exportSimple(outfile, level, name)
        else:    # category == MixedContainer.CategoryComplex
            self.value.export(
                outfile, level, namespace, name_=name,
                pretty_print=pretty_print)
    def exportSimple(self, outfile, level, name):
        if self.content_type == MixedContainer.TypeString:
            outfile.write('<%s>%s</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeInteger or \
                self.content_type == MixedContainer.TypeBoolean:
            outfile.write('<%s>%d</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeFloat or \
                self.content_type == MixedContainer.TypeDecimal:
            outfile.write('<%s>%f</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeDouble:
            outfile.write('<%s>%g</%s>' % (
                self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeBase64:
            outfile.write('<%s>%s</%s>' % (
                self.name,
                base64.b64encode(self.value),
                self.name))
    def to_etree(self, element, mapping_=None, reverse_mapping_=None, nsmap_=None):
        if self.category == MixedContainer.CategoryText:
            # Prevent exporting empty content as empty lines.
            if self.value.strip():
                if len(element) > 0:
                    if element[-1].tail is None:
                        element[-1].tail = self.value
                    else:
                        element[-1].tail += self.value
                else:
                    if element.text is None:
                        element.text = self.value
                    else:
                        element.text += self.value
        elif self.category == MixedContainer.CategorySimple:
            subelement = etree_.SubElement(
                element, '%s' % self.name)
            subelement.text = self.to_etree_simple()
        else:    # category == MixedContainer.CategoryComplex
            self.value.to_etree(element)
    def to_etree_simple(self, mapping_=None, reverse_mapping_=None, nsmap_=None):
        if self.content_type == MixedContainer.TypeString:
            text = self.value
        elif (self.content_type == MixedContainer.TypeInteger or
                self.content_type == MixedContainer.TypeBoolean):
            text = '%d' % self.value
        elif (self.content_type == MixedContainer.TypeFloat or
                self.content_type == MixedContainer.TypeDecimal):
            text = '%f' % self.value
        elif self.content_type == MixedContainer.TypeDouble:
            text = '%g' % self.value
        elif self.content_type == MixedContainer.TypeBase64:
            text = '%s' % base64.b64encode(self.value)
        return text
    def exportLiteral(self, outfile, level, name):
        if self.category == MixedContainer.CategoryText:
            showIndent(outfile, level)
            outfile.write(
                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
                    self.category, self.content_type,
                    self.name, self.value))
        elif self.category == MixedContainer.CategorySimple:
            showIndent(outfile, level)
            outfile.write(
                'model_.MixedContainer(%d, %d, "%s", "%s"),\n' % (
                    self.category, self.content_type,
                    self.name, self.value))
        else:    # category == MixedContainer.CategoryComplex
            showIndent(outfile, level)
            outfile.write(
                'model_.MixedContainer(%d, %d, "%s",\n' % (
                    self.category, self.content_type, self.name,))
            self.value.exportLiteral(outfile, level + 1)
            showIndent(outfile, level)
            outfile.write(')\n')


class MemberSpec_(object):
    def __init__(self, name='', data_type='', container=0,
            optional=0, child_attrs=None, choice=None):
        self.name = name
        self.data_type = data_type
        self.container = container
        self.child_attrs = child_attrs
        self.choice = choice
        self.optional = optional
    def set_name(self, name): self.name = name
    def get_name(self): return self.name
    def set_data_type(self, data_type): self.data_type = data_type
    def get_data_type_chain(self): return self.data_type
    def get_data_type(self):
        if isinstance(self.data_type, list):
            if len(self.data_type) > 0:
                return self.data_type[-1]
            else:
                return 'xs:string'
        else:
            return self.data_type
    def set_container(self, container): self.container = container
    def get_container(self): return self.container
    def set_child_attrs(self, child_attrs): self.child_attrs = child_attrs
    def get_child_attrs(self): return self.child_attrs
    def set_choice(self, choice): self.choice = choice
    def get_choice(self): return self.choice
    def set_optional(self, optional): self.optional = optional
    def get_optional(self): return self.optional


def _cast(typ, value):
    if typ is None or value is None:
        return value
    return typ(value)


#
# Start enum classes
#
class com_cisag_app_general_CommMedia(str, Enum):
    EMAIL='EMAIL'
    TELEFAX='TELEFAX'
    TELEPHONE='TELEPHONE'
    TELEX='TELEX'
    URL='URL'
    _=''


class com_cisag_app_general_Gender(str, Enum):
    FEMALE='FEMALE'
    MALE='MALE'
    UNKNOWN='UNKNOWN'
    _=''


class com_cisag_app_general_PartnerCustomerStatus(str, Enum):
    ON_HOLD='ON_HOLD'
    RELEASED='RELEASED'
    _=''


#
# Start data representation classes
#
class semiramis(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, created=None, locale=None, nlsMode='SINGLE_LANGUAGE', dateTimeMode='COMPACT', Partner=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        if isinstance(created, BaseStrType_):
            initvalue_ = datetime_.datetime.strptime(created, '%Y-%m-%dT%H:%M:%S')
        else:
            initvalue_ = created
        self.created = initvalue_
        self.locale = _cast(None, locale)
        self.locale_nsprefix_ = None
        self.nlsMode = _cast(None, nlsMode)
        self.nlsMode_nsprefix_ = None
        self.dateTimeMode = _cast(None, dateTimeMode)
        self.dateTimeMode_nsprefix_ = None
        if Partner is None:
            self.Partner = []
        else:
            self.Partner = Partner
        self.Partner_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, semiramis)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if semiramis.subclass:
            return semiramis.subclass(*args_, **kwargs_)
        else:
            return semiramis(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_Partner(self):
        return self.Partner
    def set_Partner(self, Partner):
        self.Partner = Partner
    def add_Partner(self, value):
        self.Partner.append(value)
    def insert_Partner_at(self, index, value):
        self.Partner.insert(index, value)
    def replace_Partner_at(self, index, value):
        self.Partner[index] = value
    def get_created(self):
        return self.created
    def set_created(self, created):
        self.created = created
    def get_locale(self):
        return self.locale
    def set_locale(self, locale):
        self.locale = locale
    def get_nlsMode(self):
        return self.nlsMode
    def set_nlsMode(self, nlsMode):
        self.nlsMode = nlsMode
    def get_dateTimeMode(self):
        return self.dateTimeMode
    def set_dateTimeMode(self, dateTimeMode):
        self.dateTimeMode = dateTimeMode
    def has__content(self):
        if (
            self.Partner
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='semiramis', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('semiramis')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'semiramis':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='semiramis')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='semiramis', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='semiramis'):
        if self.created is not None and 'created' not in already_processed:
            already_processed.add('created')
            outfile.write(' created="%s"' % self.gds_format_datetime(self.created, input_name='created'))
        if self.locale is not None and 'locale' not in already_processed:
            already_processed.add('locale')
            outfile.write(' locale=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.locale), input_name='locale')), ))
        if self.nlsMode != "SINGLE_LANGUAGE" and 'nlsMode' not in already_processed:
            already_processed.add('nlsMode')
            outfile.write(' nlsMode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.nlsMode), input_name='nlsMode')), ))
        if self.dateTimeMode != "COMPACT" and 'dateTimeMode' not in already_processed:
            already_processed.add('dateTimeMode')
            outfile.write(' dateTimeMode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.dateTimeMode), input_name='dateTimeMode')), ))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='semiramis', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for Partner_ in self.Partner:
            namespaceprefix_ = self.Partner_nsprefix_ + ':' if (UseCapturedNS_ and self.Partner_nsprefix_) else ''
            Partner_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Partner', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('created', node)
        if value is not None and 'created' not in already_processed:
            already_processed.add('created')
            try:
                self.created = self.gds_parse_datetime(value)
            except ValueError as exp:
                raise ValueError('Bad date-time attribute (created): %s' % exp)
        value = find_attr_value_('locale', node)
        if value is not None and 'locale' not in already_processed:
            already_processed.add('locale')
            self.locale = value
        value = find_attr_value_('nlsMode', node)
        if value is not None and 'nlsMode' not in already_processed:
            already_processed.add('nlsMode')
            self.nlsMode = value
        value = find_attr_value_('dateTimeMode', node)
        if value is not None and 'dateTimeMode' not in already_processed:
            already_processed.add('dateTimeMode')
            self.dateTimeMode = value
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'Partner':
            obj_ = PartnerType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Partner.append(obj_)
            obj_.original_tagname_ = 'Partner'
# end class semiramis


class PartnerType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, number=None, searchString=None, name=None, person=None, organizationalUnit=None, customerStatus=None, addressData=None, Customer=None, PartnerAccountingData=None, CommunicationData=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.number = number
        self.number_nsprefix_ = None
        self.searchString = searchString
        self.searchString_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.person = person
        self.person_nsprefix_ = None
        self.organizationalUnit = organizationalUnit
        self.organizationalUnit_nsprefix_ = None
        self.customerStatus = customerStatus
        self.validate_com_cisag_app_general_PartnerCustomerStatus(self.customerStatus)
        self.customerStatus_nsprefix_ = None
        self.addressData = addressData
        self.addressData_nsprefix_ = None
        if Customer is None:
            self.Customer = []
        else:
            self.Customer = Customer
        self.Customer_nsprefix_ = None
        if PartnerAccountingData is None:
            self.PartnerAccountingData = []
        else:
            self.PartnerAccountingData = PartnerAccountingData
        self.PartnerAccountingData_nsprefix_ = None
        if CommunicationData is None:
            self.CommunicationData = []
        else:
            self.CommunicationData = CommunicationData
        self.CommunicationData_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PartnerType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PartnerType.subclass:
            return PartnerType.subclass(*args_, **kwargs_)
        else:
            return PartnerType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_number(self):
        return self.number
    def set_number(self, number):
        self.number = number
    def get_searchString(self):
        return self.searchString
    def set_searchString(self, searchString):
        self.searchString = searchString
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_person(self):
        return self.person
    def set_person(self, person):
        self.person = person
    def get_organizationalUnit(self):
        return self.organizationalUnit
    def set_organizationalUnit(self, organizationalUnit):
        self.organizationalUnit = organizationalUnit
    def get_customerStatus(self):
        return self.customerStatus
    def set_customerStatus(self, customerStatus):
        self.customerStatus = customerStatus
    def get_addressData(self):
        return self.addressData
    def set_addressData(self, addressData):
        self.addressData = addressData
    def get_Customer(self):
        return self.Customer
    def set_Customer(self, Customer):
        self.Customer = Customer
    def add_Customer(self, value):
        self.Customer.append(value)
    def insert_Customer_at(self, index, value):
        self.Customer.insert(index, value)
    def replace_Customer_at(self, index, value):
        self.Customer[index] = value
    def get_PartnerAccountingData(self):
        return self.PartnerAccountingData
    def set_PartnerAccountingData(self, PartnerAccountingData):
        self.PartnerAccountingData = PartnerAccountingData
    def add_PartnerAccountingData(self, value):
        self.PartnerAccountingData.append(value)
    def insert_PartnerAccountingData_at(self, index, value):
        self.PartnerAccountingData.insert(index, value)
    def replace_PartnerAccountingData_at(self, index, value):
        self.PartnerAccountingData[index] = value
    def get_CommunicationData(self):
        return self.CommunicationData
    def set_CommunicationData(self, CommunicationData):
        self.CommunicationData = CommunicationData
    def add_CommunicationData(self, value):
        self.CommunicationData.append(value)
    def insert_CommunicationData_at(self, index, value):
        self.CommunicationData.insert(index, value)
    def replace_CommunicationData_at(self, index, value):
        self.CommunicationData[index] = value
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def validate_com_cisag_app_general_PartnerCustomerStatus(self, value):
        result = True
        # Validate type com.cisag.app.general.PartnerCustomerStatus, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if not isinstance(value, str):
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })
                return False
            value = value
            enumerations = ['ON_HOLD', 'RELEASED', '']
            if value not in enumerations:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on com.cisag.app.general.PartnerCustomerStatus' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.number is not None or
            self.searchString is not None or
            self.name is not None or
            self.person is not None or
            self.organizationalUnit is not None or
            self.customerStatus is not None or
            self.addressData is not None or
            self.Customer or
            self.PartnerAccountingData or
            self.CommunicationData
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartnerType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'PartnerType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PartnerType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartnerType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PartnerType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.number is not None:
            namespaceprefix_ = self.number_nsprefix_ + ':' if (UseCapturedNS_ and self.number_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snumber>%s</%snumber>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.number), input_name='number')), namespaceprefix_ , eol_))
        if self.searchString is not None:
            namespaceprefix_ = self.searchString_nsprefix_ + ':' if (UseCapturedNS_ and self.searchString_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssearchString>%s</%ssearchString>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.searchString), input_name='searchString')), namespaceprefix_ , eol_))
        if self.name is not None:
            namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname>%s</%sname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_))
        if self.person is not None:
            namespaceprefix_ = self.person_nsprefix_ + ':' if (UseCapturedNS_ and self.person_nsprefix_) else ''
            self.person.export(outfile, level, namespaceprefix_, namespacedef_='', name_='person', pretty_print=pretty_print)
        if self.organizationalUnit is not None:
            namespaceprefix_ = self.organizationalUnit_nsprefix_ + ':' if (UseCapturedNS_ and self.organizationalUnit_nsprefix_) else ''
            self.organizationalUnit.export(outfile, level, namespaceprefix_, namespacedef_='', name_='organizationalUnit', pretty_print=pretty_print)
        if self.customerStatus is not None:
            namespaceprefix_ = self.customerStatus_nsprefix_ + ':' if (UseCapturedNS_ and self.customerStatus_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scustomerStatus>%s</%scustomerStatus>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.customerStatus), input_name='customerStatus')), namespaceprefix_ , eol_))
        if self.addressData is not None:
            namespaceprefix_ = self.addressData_nsprefix_ + ':' if (UseCapturedNS_ and self.addressData_nsprefix_) else ''
            self.addressData.export(outfile, level, namespaceprefix_, namespacedef_='', name_='addressData', pretty_print=pretty_print)
        for Customer_ in self.Customer:
            namespaceprefix_ = self.Customer_nsprefix_ + ':' if (UseCapturedNS_ and self.Customer_nsprefix_) else ''
            Customer_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Customer', pretty_print=pretty_print)
        for PartnerAccountingData_ in self.PartnerAccountingData:
            namespaceprefix_ = self.PartnerAccountingData_nsprefix_ + ':' if (UseCapturedNS_ and self.PartnerAccountingData_nsprefix_) else ''
            PartnerAccountingData_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='PartnerAccountingData', pretty_print=pretty_print)
        for CommunicationData_ in self.CommunicationData:
            namespaceprefix_ = self.CommunicationData_nsprefix_ + ':' if (UseCapturedNS_ and self.CommunicationData_nsprefix_) else ''
            CommunicationData_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='CommunicationData', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'number':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'number')
            value_ = self.gds_validate_string(value_, node, 'number')
            self.number = value_
            self.number_nsprefix_ = child_.prefix
        elif nodeName_ == 'searchString':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'searchString')
            value_ = self.gds_validate_string(value_, node, 'searchString')
            self.searchString = value_
            self.searchString_nsprefix_ = child_.prefix
        elif nodeName_ == 'name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name')
            value_ = self.gds_validate_string(value_, node, 'name')
            self.name = value_
            self.name_nsprefix_ = child_.prefix
        elif nodeName_ == 'person':
            obj_ = personType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.person = obj_
            obj_.original_tagname_ = 'person'
        elif nodeName_ == 'organizationalUnit':
            obj_ = organizationalUnitType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.organizationalUnit = obj_
            obj_.original_tagname_ = 'organizationalUnit'
        elif nodeName_ == 'customerStatus':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'customerStatus')
            value_ = self.gds_validate_string(value_, node, 'customerStatus')
            self.customerStatus = value_
            self.customerStatus_nsprefix_ = child_.prefix
            # validate type com.cisag.app.general.PartnerCustomerStatus
            self.validate_com_cisag_app_general_PartnerCustomerStatus(self.customerStatus)
        elif nodeName_ == 'addressData':
            obj_ = addressDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.addressData = obj_
            obj_.original_tagname_ = 'addressData'
        elif nodeName_ == 'Customer':
            obj_ = CustomerType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Customer.append(obj_)
            obj_.original_tagname_ = 'Customer'
        elif nodeName_ == 'PartnerAccountingData':
            obj_ = PartnerAccountingDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.PartnerAccountingData.append(obj_)
            obj_.original_tagname_ = 'PartnerAccountingData'
        elif nodeName_ == 'CommunicationData':
            obj_ = CommunicationDataType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.CommunicationData.append(obj_)
            obj_.original_tagname_ = 'CommunicationData'
# end class PartnerType


class personType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, givenName=None, surname=None, fullName=None, gender=None, Salutation=None, Title=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.givenName = givenName
        self.givenName_nsprefix_ = None
        self.surname = surname
        self.surname_nsprefix_ = None
        self.fullName = fullName
        self.fullName_nsprefix_ = None
        self.gender = gender
        self.validate_com_cisag_app_general_Gender(self.gender)
        self.gender_nsprefix_ = None
        self.Salutation = Salutation
        self.Salutation_nsprefix_ = None
        self.Title = Title
        self.Title_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, personType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if personType.subclass:
            return personType.subclass(*args_, **kwargs_)
        else:
            return personType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_givenName(self):
        return self.givenName
    def set_givenName(self, givenName):
        self.givenName = givenName
    def get_surname(self):
        return self.surname
    def set_surname(self, surname):
        self.surname = surname
    def get_fullName(self):
        return self.fullName
    def set_fullName(self, fullName):
        self.fullName = fullName
    def get_gender(self):
        return self.gender
    def set_gender(self, gender):
        self.gender = gender
    def get_Salutation(self):
        return self.Salutation
    def set_Salutation(self, Salutation):
        self.Salutation = Salutation
    def get_Title(self):
        return self.Title
    def set_Title(self, Title):
        self.Title = Title
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def validate_com_cisag_app_general_Gender(self, value):
        result = True
        # Validate type com.cisag.app.general.Gender, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if not isinstance(value, str):
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })
                return False
            value = value
            enumerations = ['FEMALE', 'MALE', 'UNKNOWN', '']
            if value not in enumerations:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on com.cisag.app.general.Gender' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.givenName is not None or
            self.surname is not None or
            self.fullName is not None or
            self.gender is not None or
            self.Salutation is not None or
            self.Title is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='personType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('personType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'personType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='personType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='personType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='personType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='personType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.givenName is not None:
            namespaceprefix_ = self.givenName_nsprefix_ + ':' if (UseCapturedNS_ and self.givenName_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sgivenName>%s</%sgivenName>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.givenName), input_name='givenName')), namespaceprefix_ , eol_))
        if self.surname is not None:
            namespaceprefix_ = self.surname_nsprefix_ + ':' if (UseCapturedNS_ and self.surname_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%ssurname>%s</%ssurname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.surname), input_name='surname')), namespaceprefix_ , eol_))
        if self.fullName is not None:
            namespaceprefix_ = self.fullName_nsprefix_ + ':' if (UseCapturedNS_ and self.fullName_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sfullName>%s</%sfullName>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.fullName), input_name='fullName')), namespaceprefix_ , eol_))
        if self.gender is not None:
            namespaceprefix_ = self.gender_nsprefix_ + ':' if (UseCapturedNS_ and self.gender_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sgender>%s</%sgender>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.gender), input_name='gender')), namespaceprefix_ , eol_))
        if self.Salutation is not None:
            namespaceprefix_ = self.Salutation_nsprefix_ + ':' if (UseCapturedNS_ and self.Salutation_nsprefix_) else ''
            self.Salutation.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Salutation', pretty_print=pretty_print)
        if self.Title is not None:
            namespaceprefix_ = self.Title_nsprefix_ + ':' if (UseCapturedNS_ and self.Title_nsprefix_) else ''
            self.Title.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Title', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'givenName':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'givenName')
            value_ = self.gds_validate_string(value_, node, 'givenName')
            self.givenName = value_
            self.givenName_nsprefix_ = child_.prefix
        elif nodeName_ == 'surname':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'surname')
            value_ = self.gds_validate_string(value_, node, 'surname')
            self.surname = value_
            self.surname_nsprefix_ = child_.prefix
        elif nodeName_ == 'fullName':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'fullName')
            value_ = self.gds_validate_string(value_, node, 'fullName')
            self.fullName = value_
            self.fullName_nsprefix_ = child_.prefix
        elif nodeName_ == 'gender':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'gender')
            value_ = self.gds_validate_string(value_, node, 'gender')
            self.gender = value_
            self.gender_nsprefix_ = child_.prefix
            # validate type com.cisag.app.general.Gender
            self.validate_com_cisag_app_general_Gender(self.gender)
        elif nodeName_ == 'Salutation':
            obj_ = SalutationType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Salutation = obj_
            obj_.original_tagname_ = 'Salutation'
        elif nodeName_ == 'Title':
            obj_ = TitleType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Title = obj_
            obj_.original_tagname_ = 'Title'
# end class personType


class SalutationType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, name=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SalutationType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SalutationType.subclass:
            return SalutationType.subclass(*args_, **kwargs_)
        else:
            return SalutationType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='SalutationType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SalutationType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'SalutationType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='SalutationType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SalutationType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='SalutationType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='SalutationType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.name is not None:
            namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname>%s</%sname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name')
            value_ = self.gds_validate_string(value_, node, 'name')
            self.name = value_
            self.name_nsprefix_ = child_.prefix
# end class SalutationType


class TitleType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, name=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, TitleType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if TitleType.subclass:
            return TitleType.subclass(*args_, **kwargs_)
        else:
            return TitleType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.name is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='TitleType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('TitleType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'TitleType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='TitleType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='TitleType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='TitleType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='TitleType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.name is not None:
            namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname>%s</%sname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name')
            value_ = self.gds_validate_string(value_, node, 'name')
            self.name = value_
            self.name_nsprefix_ = child_.prefix
# end class TitleType


class organizationalUnitType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, ilnNumber=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.ilnNumber = ilnNumber
        self.ilnNumber_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, organizationalUnitType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if organizationalUnitType.subclass:
            return organizationalUnitType.subclass(*args_, **kwargs_)
        else:
            return organizationalUnitType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_ilnNumber(self):
        return self.ilnNumber
    def set_ilnNumber(self, ilnNumber):
        self.ilnNumber = ilnNumber
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.ilnNumber is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='organizationalUnitType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('organizationalUnitType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'organizationalUnitType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='organizationalUnitType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='organizationalUnitType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='organizationalUnitType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='organizationalUnitType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ilnNumber is not None:
            namespaceprefix_ = self.ilnNumber_nsprefix_ + ':' if (UseCapturedNS_ and self.ilnNumber_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%silnNumber>%s</%silnNumber>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.ilnNumber), input_name='ilnNumber')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ilnNumber':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'ilnNumber')
            value_ = self.gds_validate_string(value_, node, 'ilnNumber')
            self.ilnNumber = value_
            self.ilnNumber_nsprefix_ = child_.prefix
# end class organizationalUnitType


class addressDataType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, street=None, city=None, postalCode=None, Country=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.street = street
        self.street_nsprefix_ = None
        self.city = city
        self.city_nsprefix_ = None
        self.postalCode = postalCode
        self.postalCode_nsprefix_ = None
        self.Country = Country
        self.Country_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, addressDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if addressDataType.subclass:
            return addressDataType.subclass(*args_, **kwargs_)
        else:
            return addressDataType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_street(self):
        return self.street
    def set_street(self, street):
        self.street = street
    def get_city(self):
        return self.city
    def set_city(self, city):
        self.city = city
    def get_postalCode(self):
        return self.postalCode
    def set_postalCode(self, postalCode):
        self.postalCode = postalCode
    def get_Country(self):
        return self.Country
    def set_Country(self, Country):
        self.Country = Country
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.street is not None or
            self.city is not None or
            self.postalCode is not None or
            self.Country is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='addressDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('addressDataType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'addressDataType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='addressDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='addressDataType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='addressDataType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='addressDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.street is not None:
            namespaceprefix_ = self.street_nsprefix_ + ':' if (UseCapturedNS_ and self.street_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sstreet>%s</%sstreet>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.street), input_name='street')), namespaceprefix_ , eol_))
        if self.city is not None:
            namespaceprefix_ = self.city_nsprefix_ + ':' if (UseCapturedNS_ and self.city_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scity>%s</%scity>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.city), input_name='city')), namespaceprefix_ , eol_))
        if self.postalCode is not None:
            namespaceprefix_ = self.postalCode_nsprefix_ + ':' if (UseCapturedNS_ and self.postalCode_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%spostalCode>%s</%spostalCode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.postalCode), input_name='postalCode')), namespaceprefix_ , eol_))
        if self.Country is not None:
            namespaceprefix_ = self.Country_nsprefix_ + ':' if (UseCapturedNS_ and self.Country_nsprefix_) else ''
            self.Country.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Country', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'street':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'street')
            value_ = self.gds_validate_string(value_, node, 'street')
            self.street = value_
            self.street_nsprefix_ = child_.prefix
        elif nodeName_ == 'city':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'city')
            value_ = self.gds_validate_string(value_, node, 'city')
            self.city = value_
            self.city_nsprefix_ = child_.prefix
        elif nodeName_ == 'postalCode':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'postalCode')
            value_ = self.gds_validate_string(value_, node, 'postalCode')
            self.postalCode = value_
            self.postalCode_nsprefix_ = child_.prefix
        elif nodeName_ == 'Country':
            obj_ = CountryType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Country = obj_
            obj_.original_tagname_ = 'Country'
# end class addressDataType


class CountryType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, isoCode=None, description=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.isoCode = isoCode
        self.isoCode_nsprefix_ = None
        self.description = description
        self.description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CountryType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CountryType.subclass:
            return CountryType.subclass(*args_, **kwargs_)
        else:
            return CountryType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_isoCode(self):
        return self.isoCode
    def set_isoCode(self, isoCode):
        self.isoCode = isoCode
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.isoCode is not None or
            self.description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CountryType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CountryType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'CountryType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CountryType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CountryType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CountryType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CountryType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.isoCode is not None:
            namespaceprefix_ = self.isoCode_nsprefix_ + ':' if (UseCapturedNS_ and self.isoCode_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sisoCode>%s</%sisoCode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.isoCode), input_name='isoCode')), namespaceprefix_ , eol_))
        if self.description is not None:
            namespaceprefix_ = self.description_nsprefix_ + ':' if (UseCapturedNS_ and self.description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdescription>%s</%sdescription>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.description), input_name='description')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'isoCode':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'isoCode')
            value_ = self.gds_validate_string(value_, node, 'isoCode')
            self.isoCode = value_
            self.isoCode_nsprefix_ = child_.prefix
        elif nodeName_ == 'description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'description')
            value_ = self.gds_validate_string(value_, node, 'description')
            self.description = value_
            self.description_nsprefix_ = child_.prefix
# end class CountryType


class CustomerType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, allowOrders=None, deliveryDataInfo=None, classification1=None, classification2=None, classification5=None, PriceListing=None, Imp_SizeSurchargeListing=None, Imp_CustomerPossibleSalesItem=None, Imp_CustomerPossibleOrderTypes=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.allowOrders = allowOrders
        self.allowOrders_nsprefix_ = None
        self.deliveryDataInfo = deliveryDataInfo
        self.deliveryDataInfo_nsprefix_ = None
        self.classification1 = classification1
        self.classification1_nsprefix_ = None
        self.classification2 = classification2
        self.classification2_nsprefix_ = None
        self.classification5 = classification5
        self.classification5_nsprefix_ = None
        self.PriceListing = PriceListing
        self.PriceListing_nsprefix_ = None
        self.Imp_SizeSurchargeListing = Imp_SizeSurchargeListing
        self.Imp_SizeSurchargeListing_nsprefix_ = None
        if Imp_CustomerPossibleSalesItem is None:
            self.Imp_CustomerPossibleSalesItem = []
        else:
            self.Imp_CustomerPossibleSalesItem = Imp_CustomerPossibleSalesItem
        self.Imp_CustomerPossibleSalesItem_nsprefix_ = None
        if Imp_CustomerPossibleOrderTypes is None:
            self.Imp_CustomerPossibleOrderTypes = []
        else:
            self.Imp_CustomerPossibleOrderTypes = Imp_CustomerPossibleOrderTypes
        self.Imp_CustomerPossibleOrderTypes_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CustomerType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CustomerType.subclass:
            return CustomerType.subclass(*args_, **kwargs_)
        else:
            return CustomerType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_allowOrders(self):
        return self.allowOrders
    def set_allowOrders(self, allowOrders):
        self.allowOrders = allowOrders
    def get_deliveryDataInfo(self):
        return self.deliveryDataInfo
    def set_deliveryDataInfo(self, deliveryDataInfo):
        self.deliveryDataInfo = deliveryDataInfo
    def get_classification1(self):
        return self.classification1
    def set_classification1(self, classification1):
        self.classification1 = classification1
    def get_classification2(self):
        return self.classification2
    def set_classification2(self, classification2):
        self.classification2 = classification2
    def get_classification5(self):
        return self.classification5
    def set_classification5(self, classification5):
        self.classification5 = classification5
    def get_PriceListing(self):
        return self.PriceListing
    def set_PriceListing(self, PriceListing):
        self.PriceListing = PriceListing
    def get_Imp_SizeSurchargeListing(self):
        return self.Imp_SizeSurchargeListing
    def set_Imp_SizeSurchargeListing(self, Imp_SizeSurchargeListing):
        self.Imp_SizeSurchargeListing = Imp_SizeSurchargeListing
    def get_Imp_CustomerPossibleSalesItem(self):
        return self.Imp_CustomerPossibleSalesItem
    def set_Imp_CustomerPossibleSalesItem(self, Imp_CustomerPossibleSalesItem):
        self.Imp_CustomerPossibleSalesItem = Imp_CustomerPossibleSalesItem
    def add_Imp_CustomerPossibleSalesItem(self, value):
        self.Imp_CustomerPossibleSalesItem.append(value)
    def insert_Imp_CustomerPossibleSalesItem_at(self, index, value):
        self.Imp_CustomerPossibleSalesItem.insert(index, value)
    def replace_Imp_CustomerPossibleSalesItem_at(self, index, value):
        self.Imp_CustomerPossibleSalesItem[index] = value
    def get_Imp_CustomerPossibleOrderTypes(self):
        return self.Imp_CustomerPossibleOrderTypes
    def set_Imp_CustomerPossibleOrderTypes(self, Imp_CustomerPossibleOrderTypes):
        self.Imp_CustomerPossibleOrderTypes = Imp_CustomerPossibleOrderTypes
    def add_Imp_CustomerPossibleOrderTypes(self, value):
        self.Imp_CustomerPossibleOrderTypes.append(value)
    def insert_Imp_CustomerPossibleOrderTypes_at(self, index, value):
        self.Imp_CustomerPossibleOrderTypes.insert(index, value)
    def replace_Imp_CustomerPossibleOrderTypes_at(self, index, value):
        self.Imp_CustomerPossibleOrderTypes[index] = value
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.allowOrders is not None or
            self.deliveryDataInfo is not None or
            self.classification1 is not None or
            self.classification2 is not None or
            self.classification5 is not None or
            self.PriceListing is not None or
            self.Imp_SizeSurchargeListing is not None or
            self.Imp_CustomerPossibleSalesItem or
            self.Imp_CustomerPossibleOrderTypes
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CustomerType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CustomerType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'CustomerType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CustomerType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CustomerType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CustomerType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CustomerType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.allowOrders is not None:
            namespaceprefix_ = self.allowOrders_nsprefix_ + ':' if (UseCapturedNS_ and self.allowOrders_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sallowOrders>%s</%sallowOrders>%s' % (namespaceprefix_ , self.gds_format_boolean(self.allowOrders, input_name='allowOrders'), namespaceprefix_ , eol_))
        if self.deliveryDataInfo is not None:
            namespaceprefix_ = self.deliveryDataInfo_nsprefix_ + ':' if (UseCapturedNS_ and self.deliveryDataInfo_nsprefix_) else ''
            self.deliveryDataInfo.export(outfile, level, namespaceprefix_, namespacedef_='', name_='deliveryDataInfo', pretty_print=pretty_print)
        if self.classification1 is not None:
            namespaceprefix_ = self.classification1_nsprefix_ + ':' if (UseCapturedNS_ and self.classification1_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sclassification1>%s</%sclassification1>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.classification1), input_name='classification1')), namespaceprefix_ , eol_))
        if self.classification2 is not None:
            namespaceprefix_ = self.classification2_nsprefix_ + ':' if (UseCapturedNS_ and self.classification2_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sclassification2>%s</%sclassification2>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.classification2), input_name='classification2')), namespaceprefix_ , eol_))
        if self.classification5 is not None:
            namespaceprefix_ = self.classification5_nsprefix_ + ':' if (UseCapturedNS_ and self.classification5_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sclassification5>%s</%sclassification5>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.classification5), input_name='classification5')), namespaceprefix_ , eol_))
        if self.PriceListing is not None:
            namespaceprefix_ = self.PriceListing_nsprefix_ + ':' if (UseCapturedNS_ and self.PriceListing_nsprefix_) else ''
            self.PriceListing.export(outfile, level, namespaceprefix_, namespacedef_='', name_='PriceListing', pretty_print=pretty_print)
        if self.Imp_SizeSurchargeListing is not None:
            namespaceprefix_ = self.Imp_SizeSurchargeListing_nsprefix_ + ':' if (UseCapturedNS_ and self.Imp_SizeSurchargeListing_nsprefix_) else ''
            self.Imp_SizeSurchargeListing.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Imp_SizeSurchargeListing', pretty_print=pretty_print)
        for Imp_CustomerPossibleSalesItem_ in self.Imp_CustomerPossibleSalesItem:
            namespaceprefix_ = self.Imp_CustomerPossibleSalesItem_nsprefix_ + ':' if (UseCapturedNS_ and self.Imp_CustomerPossibleSalesItem_nsprefix_) else ''
            Imp_CustomerPossibleSalesItem_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Imp_CustomerPossibleSalesItem', pretty_print=pretty_print)
        for Imp_CustomerPossibleOrderTypes_ in self.Imp_CustomerPossibleOrderTypes:
            namespaceprefix_ = self.Imp_CustomerPossibleOrderTypes_nsprefix_ + ':' if (UseCapturedNS_ and self.Imp_CustomerPossibleOrderTypes_nsprefix_) else ''
            Imp_CustomerPossibleOrderTypes_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Imp_CustomerPossibleOrderTypes', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'allowOrders':
            sval_ = child_.text
            ival_ = self.gds_parse_boolean(sval_, node, 'allowOrders')
            ival_ = self.gds_validate_boolean(ival_, node, 'allowOrders')
            self.allowOrders = ival_
            self.allowOrders_nsprefix_ = child_.prefix
        elif nodeName_ == 'deliveryDataInfo':
            obj_ = deliveryDataInfoType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.deliveryDataInfo = obj_
            obj_.original_tagname_ = 'deliveryDataInfo'
        elif nodeName_ == 'classification1':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'classification1')
            value_ = self.gds_validate_string(value_, node, 'classification1')
            self.classification1 = value_
            self.classification1_nsprefix_ = child_.prefix
        elif nodeName_ == 'classification2':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'classification2')
            value_ = self.gds_validate_string(value_, node, 'classification2')
            self.classification2 = value_
            self.classification2_nsprefix_ = child_.prefix
        elif nodeName_ == 'classification5':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'classification5')
            value_ = self.gds_validate_string(value_, node, 'classification5')
            self.classification5 = value_
            self.classification5_nsprefix_ = child_.prefix
        elif nodeName_ == 'PriceListing':
            obj_ = PriceListingType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.PriceListing = obj_
            obj_.original_tagname_ = 'PriceListing'
        elif nodeName_ == 'Imp_SizeSurchargeListing':
            obj_ = Imp_SizeSurchargeListingType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Imp_SizeSurchargeListing = obj_
            obj_.original_tagname_ = 'Imp_SizeSurchargeListing'
        elif nodeName_ == 'Imp_CustomerPossibleSalesItem':
            obj_ = Imp_CustomerPossibleSalesItemType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Imp_CustomerPossibleSalesItem.append(obj_)
            obj_.original_tagname_ = 'Imp_CustomerPossibleSalesItem'
        elif nodeName_ == 'Imp_CustomerPossibleOrderTypes':
            obj_ = Imp_CustomerPossibleOrderTypesType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Imp_CustomerPossibleOrderTypes.append(obj_)
            obj_.original_tagname_ = 'Imp_CustomerPossibleOrderTypes'
# end class CustomerType


class deliveryDataInfoType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, ShippingTerms=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.ShippingTerms = ShippingTerms
        self.ShippingTerms_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, deliveryDataInfoType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if deliveryDataInfoType.subclass:
            return deliveryDataInfoType.subclass(*args_, **kwargs_)
        else:
            return deliveryDataInfoType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_ShippingTerms(self):
        return self.ShippingTerms
    def set_ShippingTerms(self, ShippingTerms):
        self.ShippingTerms = ShippingTerms
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.ShippingTerms is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='deliveryDataInfoType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('deliveryDataInfoType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'deliveryDataInfoType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='deliveryDataInfoType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='deliveryDataInfoType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='deliveryDataInfoType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='deliveryDataInfoType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.ShippingTerms is not None:
            namespaceprefix_ = self.ShippingTerms_nsprefix_ + ':' if (UseCapturedNS_ and self.ShippingTerms_nsprefix_) else ''
            self.ShippingTerms.export(outfile, level, namespaceprefix_, namespacedef_='', name_='ShippingTerms', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'ShippingTerms':
            obj_ = ShippingTermsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.ShippingTerms = obj_
            obj_.original_tagname_ = 'ShippingTerms'
# end class deliveryDataInfoType


class ShippingTermsType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, code=None, description=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.code = code
        self.code_nsprefix_ = None
        self.description = description
        self.description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ShippingTermsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ShippingTermsType.subclass:
            return ShippingTermsType.subclass(*args_, **kwargs_)
        else:
            return ShippingTermsType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_code(self):
        return self.code
    def set_code(self, code):
        self.code = code
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.code is not None or
            self.description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='ShippingTermsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ShippingTermsType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'ShippingTermsType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ShippingTermsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ShippingTermsType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ShippingTermsType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='ShippingTermsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.code is not None:
            namespaceprefix_ = self.code_nsprefix_ + ':' if (UseCapturedNS_ and self.code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scode>%s</%scode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.code), input_name='code')), namespaceprefix_ , eol_))
        if self.description is not None:
            namespaceprefix_ = self.description_nsprefix_ + ':' if (UseCapturedNS_ and self.description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdescription>%s</%sdescription>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.description), input_name='description')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'code')
            value_ = self.gds_validate_string(value_, node, 'code')
            self.code = value_
            self.code_nsprefix_ = child_.prefix
        elif nodeName_ == 'description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'description')
            value_ = self.gds_validate_string(value_, node, 'description')
            self.description = value_
            self.description_nsprefix_ = child_.prefix
# end class ShippingTermsType


class PriceListingType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, code=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.code = code
        self.code_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PriceListingType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PriceListingType.subclass:
            return PriceListingType.subclass(*args_, **kwargs_)
        else:
            return PriceListingType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_code(self):
        return self.code
    def set_code(self, code):
        self.code = code
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.code is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PriceListingType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PriceListingType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'PriceListingType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PriceListingType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PriceListingType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PriceListingType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PriceListingType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.code is not None:
            namespaceprefix_ = self.code_nsprefix_ + ':' if (UseCapturedNS_ and self.code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scode>%s</%scode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.code), input_name='code')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'code')
            value_ = self.gds_validate_string(value_, node, 'code')
            self.code = value_
            self.code_nsprefix_ = child_.prefix
# end class PriceListingType


class Imp_SizeSurchargeListingType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, code=None, description=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.code = code
        self.code_nsprefix_ = None
        self.description = description
        self.description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Imp_SizeSurchargeListingType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Imp_SizeSurchargeListingType.subclass:
            return Imp_SizeSurchargeListingType.subclass(*args_, **kwargs_)
        else:
            return Imp_SizeSurchargeListingType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_code(self):
        return self.code
    def set_code(self, code):
        self.code = code
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.code is not None or
            self.description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='Imp_SizeSurchargeListingType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Imp_SizeSurchargeListingType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'Imp_SizeSurchargeListingType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='Imp_SizeSurchargeListingType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Imp_SizeSurchargeListingType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='Imp_SizeSurchargeListingType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='Imp_SizeSurchargeListingType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.code is not None:
            namespaceprefix_ = self.code_nsprefix_ + ':' if (UseCapturedNS_ and self.code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scode>%s</%scode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.code), input_name='code')), namespaceprefix_ , eol_))
        if self.description is not None:
            namespaceprefix_ = self.description_nsprefix_ + ':' if (UseCapturedNS_ and self.description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdescription>%s</%sdescription>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.description), input_name='description')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'code')
            value_ = self.gds_validate_string(value_, node, 'code')
            self.code = value_
            self.code_nsprefix_ = child_.prefix
        elif nodeName_ == 'description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'description')
            value_ = self.gds_validate_string(value_, node, 'description')
            self.description = value_
            self.description_nsprefix_ = child_.prefix
# end class Imp_SizeSurchargeListingType


class Imp_CustomerPossibleSalesItemType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, Item=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.Item = Item
        self.Item_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Imp_CustomerPossibleSalesItemType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Imp_CustomerPossibleSalesItemType.subclass:
            return Imp_CustomerPossibleSalesItemType.subclass(*args_, **kwargs_)
        else:
            return Imp_CustomerPossibleSalesItemType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_Item(self):
        return self.Item
    def set_Item(self, Item):
        self.Item = Item
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.Item is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='Imp_CustomerPossibleSalesItemType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Imp_CustomerPossibleSalesItemType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'Imp_CustomerPossibleSalesItemType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='Imp_CustomerPossibleSalesItemType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Imp_CustomerPossibleSalesItemType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='Imp_CustomerPossibleSalesItemType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='Imp_CustomerPossibleSalesItemType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.Item is not None:
            namespaceprefix_ = self.Item_nsprefix_ + ':' if (UseCapturedNS_ and self.Item_nsprefix_) else ''
            self.Item.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Item', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'Item':
            obj_ = ItemType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Item = obj_
            obj_.original_tagname_ = 'Item'
# end class Imp_CustomerPossibleSalesItemType


class ItemType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, eans=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        if eans is None:
            self.eans = []
        else:
            self.eans = eans
        self.eans_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, ItemType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if ItemType.subclass:
            return ItemType.subclass(*args_, **kwargs_)
        else:
            return ItemType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_eans(self):
        return self.eans
    def set_eans(self, eans):
        self.eans = eans
    def add_eans(self, value):
        self.eans.append(value)
    def insert_eans_at(self, index, value):
        self.eans.insert(index, value)
    def replace_eans_at(self, index, value):
        self.eans[index] = value
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.eans
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='ItemType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('ItemType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'ItemType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='ItemType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='ItemType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='ItemType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='ItemType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        for eans_ in self.eans:
            namespaceprefix_ = self.eans_nsprefix_ + ':' if (UseCapturedNS_ and self.eans_nsprefix_) else ''
            eans_.export(outfile, level, namespaceprefix_, namespacedef_='', name_='eans', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'eans':
            obj_ = eansType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.eans.append(obj_)
            obj_.original_tagname_ = 'eans'
# end class ItemType


class eansType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, index=None, valueOf_=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.index = _cast(int, index)
        self.index_nsprefix_ = None
        self.valueOf_ = valueOf_
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, eansType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if eansType.subclass:
            return eansType.subclass(*args_, **kwargs_)
        else:
            return eansType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_index(self):
        return self.index
    def set_index(self, index):
        self.index = index
    def get_valueOf_(self): return self.valueOf_
    def set_valueOf_(self, valueOf_): self.valueOf_ = valueOf_
    def validate_java_lang_Integer(self, value):
        # Validate type java.lang.Integer, a restriction on xsd:integer.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if not isinstance(value, int):
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (int)' % {"value": value, "lineno": lineno, })
                return False
            if value < -2147483648:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd minInclusive restriction on java.lang.Integer' % {"value": value, "lineno": lineno} )
                result = False
            if value > 2147483647:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd maxInclusive restriction on java.lang.Integer' % {"value": value, "lineno": lineno} )
                result = False
    def has__content(self):
        if (
            (1 if type(self.valueOf_) in [int,float] else self.valueOf_)
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='eansType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('eansType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'eansType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='eansType')
        outfile.write('>')
        self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_, pretty_print=pretty_print)
        outfile.write(self.convert_unicode(self.valueOf_))
        outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='eansType'):
        if self.index is not None and 'index' not in already_processed:
            already_processed.add('index')
            outfile.write(' index="%s"' % self.gds_format_integer(self.index, input_name='index'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_='', name_='eansType', fromsubclass_=False, pretty_print=True):
        pass
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        self.valueOf_ = get_all_text_(node)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('index', node)
        if value is not None and 'index' not in already_processed:
            already_processed.add('index')
            self.index = self.gds_parse_integer(value, node, 'index')
            self.validate_java_lang_Integer(self.index)    # validate type java.lang.Integer
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        pass
# end class eansType


class Imp_CustomerPossibleOrderTypesType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, PriceListing=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.PriceListing = PriceListing
        self.PriceListing_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, Imp_CustomerPossibleOrderTypesType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if Imp_CustomerPossibleOrderTypesType.subclass:
            return Imp_CustomerPossibleOrderTypesType.subclass(*args_, **kwargs_)
        else:
            return Imp_CustomerPossibleOrderTypesType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_PriceListing(self):
        return self.PriceListing
    def set_PriceListing(self, PriceListing):
        self.PriceListing = PriceListing
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.PriceListing is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='Imp_CustomerPossibleOrderTypesType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('Imp_CustomerPossibleOrderTypesType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'Imp_CustomerPossibleOrderTypesType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='Imp_CustomerPossibleOrderTypesType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='Imp_CustomerPossibleOrderTypesType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='Imp_CustomerPossibleOrderTypesType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='Imp_CustomerPossibleOrderTypesType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.PriceListing is not None:
            namespaceprefix_ = self.PriceListing_nsprefix_ + ':' if (UseCapturedNS_ and self.PriceListing_nsprefix_) else ''
            self.PriceListing.export(outfile, level, namespaceprefix_, namespacedef_='', name_='PriceListing', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'PriceListing':
            obj_ = PriceListingType1.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.PriceListing = obj_
            obj_.original_tagname_ = 'PriceListing'
# end class Imp_CustomerPossibleOrderTypesType


class PriceListingType1(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, code=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.code = code
        self.code_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PriceListingType1)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PriceListingType1.subclass:
            return PriceListingType1.subclass(*args_, **kwargs_)
        else:
            return PriceListingType1(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_code(self):
        return self.code
    def set_code(self, code):
        self.code = code
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.code is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PriceListingType1', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PriceListingType1')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'PriceListingType1':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PriceListingType1')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PriceListingType1', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PriceListingType1'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PriceListingType1', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.code is not None:
            namespaceprefix_ = self.code_nsprefix_ + ':' if (UseCapturedNS_ and self.code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scode>%s</%scode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.code), input_name='code')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'code')
            value_ = self.gds_validate_string(value_, node, 'code')
            self.code = value_
            self.code_nsprefix_ = child_.prefix
# end class PriceListingType1


class PartnerAccountingDataType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, SalesPaymentTerms=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.SalesPaymentTerms = SalesPaymentTerms
        self.SalesPaymentTerms_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, PartnerAccountingDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if PartnerAccountingDataType.subclass:
            return PartnerAccountingDataType.subclass(*args_, **kwargs_)
        else:
            return PartnerAccountingDataType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_SalesPaymentTerms(self):
        return self.SalesPaymentTerms
    def set_SalesPaymentTerms(self, SalesPaymentTerms):
        self.SalesPaymentTerms = SalesPaymentTerms
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.SalesPaymentTerms is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerAccountingDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('PartnerAccountingDataType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'PartnerAccountingDataType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='PartnerAccountingDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='PartnerAccountingDataType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='PartnerAccountingDataType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='PartnerAccountingDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.SalesPaymentTerms is not None:
            namespaceprefix_ = self.SalesPaymentTerms_nsprefix_ + ':' if (UseCapturedNS_ and self.SalesPaymentTerms_nsprefix_) else ''
            self.SalesPaymentTerms.export(outfile, level, namespaceprefix_, namespacedef_='', name_='SalesPaymentTerms', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'SalesPaymentTerms':
            obj_ = SalesPaymentTermsType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.SalesPaymentTerms = obj_
            obj_.original_tagname_ = 'SalesPaymentTerms'
# end class PartnerAccountingDataType


class SalesPaymentTermsType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, code=None, description=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.code = code
        self.code_nsprefix_ = None
        self.description = description
        self.description_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, SalesPaymentTermsType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if SalesPaymentTermsType.subclass:
            return SalesPaymentTermsType.subclass(*args_, **kwargs_)
        else:
            return SalesPaymentTermsType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_code(self):
        return self.code
    def set_code(self, code):
        self.code = code
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.code is not None or
            self.description is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='SalesPaymentTermsType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('SalesPaymentTermsType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'SalesPaymentTermsType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='SalesPaymentTermsType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='SalesPaymentTermsType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='SalesPaymentTermsType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='SalesPaymentTermsType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.code is not None:
            namespaceprefix_ = self.code_nsprefix_ + ':' if (UseCapturedNS_ and self.code_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scode>%s</%scode>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.code), input_name='code')), namespaceprefix_ , eol_))
        if self.description is not None:
            namespaceprefix_ = self.description_nsprefix_ + ':' if (UseCapturedNS_ and self.description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdescription>%s</%sdescription>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.description), input_name='description')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'code':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'code')
            value_ = self.gds_validate_string(value_, node, 'code')
            self.code = value_
            self.code_nsprefix_ = child_.prefix
        elif nodeName_ == 'description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'description')
            value_ = self.gds_validate_string(value_, node, 'description')
            self.description = value_
            self.description_nsprefix_ = child_.prefix
# end class SalesPaymentTermsType


class CommunicationDataType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, commData=None, normalizedCommData=None, Method=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.commData = commData
        self.commData_nsprefix_ = None
        self.normalizedCommData = normalizedCommData
        self.normalizedCommData_nsprefix_ = None
        self.Method = Method
        self.Method_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, CommunicationDataType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if CommunicationDataType.subclass:
            return CommunicationDataType.subclass(*args_, **kwargs_)
        else:
            return CommunicationDataType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_commData(self):
        return self.commData
    def set_commData(self, commData):
        self.commData = commData
    def get_normalizedCommData(self):
        return self.normalizedCommData
    def set_normalizedCommData(self, normalizedCommData):
        self.normalizedCommData = normalizedCommData
    def get_Method(self):
        return self.Method
    def set_Method(self, Method):
        self.Method = Method
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def has__content(self):
        if (
            self.commData is not None or
            self.normalizedCommData is not None or
            self.Method is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CommunicationDataType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('CommunicationDataType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'CommunicationDataType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='CommunicationDataType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='CommunicationDataType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='CommunicationDataType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='CommunicationDataType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.commData is not None:
            namespaceprefix_ = self.commData_nsprefix_ + ':' if (UseCapturedNS_ and self.commData_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%scommData>%s</%scommData>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.commData), input_name='commData')), namespaceprefix_ , eol_))
        if self.normalizedCommData is not None:
            namespaceprefix_ = self.normalizedCommData_nsprefix_ + ':' if (UseCapturedNS_ and self.normalizedCommData_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%snormalizedCommData>%s</%snormalizedCommData>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.normalizedCommData), input_name='normalizedCommData')), namespaceprefix_ , eol_))
        if self.Method is not None:
            namespaceprefix_ = self.Method_nsprefix_ + ':' if (UseCapturedNS_ and self.Method_nsprefix_) else ''
            self.Method.export(outfile, level, namespaceprefix_, namespacedef_='', name_='Method', pretty_print=pretty_print)
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'commData':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'commData')
            value_ = self.gds_validate_string(value_, node, 'commData')
            self.commData = value_
            self.commData_nsprefix_ = child_.prefix
        elif nodeName_ == 'normalizedCommData':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'normalizedCommData')
            value_ = self.gds_validate_string(value_, node, 'normalizedCommData')
            self.normalizedCommData = value_
            self.normalizedCommData_nsprefix_ = child_.prefix
        elif nodeName_ == 'Method':
            obj_ = MethodType.factory(parent_object_=self)
            obj_.build(child_, gds_collector_=gds_collector_)
            self.Method = obj_
            obj_.original_tagname_ = 'Method'
# end class CommunicationDataType


class MethodType(GeneratedsSuper):
    __hash__ = GeneratedsSuper.__hash__
    subclass = None
    superclass = None
    def __init__(self, mark=None, mode=None, invalid=None, name=None, description=None, media=None, gds_collector_=None, **kwargs_):
        self.gds_collector_ = gds_collector_
        self.gds_elementtree_node_ = None
        self.original_tagname_ = None
        self.parent_object_ = kwargs_.get('parent_object_')
        self.ns_prefix_ = None
        self.mark = _cast(None, mark)
        self.mark_nsprefix_ = None
        self.mode = _cast(None, mode)
        self.mode_nsprefix_ = None
        self.invalid = _cast(bool, invalid)
        self.invalid_nsprefix_ = None
        self.name = name
        self.name_nsprefix_ = None
        self.description = description
        self.description_nsprefix_ = None
        self.media = media
        self.validate_com_cisag_app_general_CommMedia(self.media)
        self.media_nsprefix_ = None
    def factory(*args_, **kwargs_):
        if CurrentSubclassModule_ is not None:
            subclass = getSubclassFromModule_(
                CurrentSubclassModule_, MethodType)
            if subclass is not None:
                return subclass(*args_, **kwargs_)
        if MethodType.subclass:
            return MethodType.subclass(*args_, **kwargs_)
        else:
            return MethodType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_ns_prefix_(self):
        return self.ns_prefix_
    def set_ns_prefix_(self, ns_prefix):
        self.ns_prefix_ = ns_prefix
    def get_name(self):
        return self.name
    def set_name(self, name):
        self.name = name
    def get_description(self):
        return self.description
    def set_description(self, description):
        self.description = description
    def get_media(self):
        return self.media
    def set_media(self, media):
        self.media = media
    def get_mark(self):
        return self.mark
    def set_mark(self, mark):
        self.mark = mark
    def get_mode(self):
        return self.mode
    def set_mode(self, mode):
        self.mode = mode
    def get_invalid(self):
        return self.invalid
    def set_invalid(self, invalid):
        self.invalid = invalid
    def validate_com_cisag_app_general_CommMedia(self, value):
        result = True
        # Validate type com.cisag.app.general.CommMedia, a restriction on xsd:string.
        if value is not None and Validate_simpletypes_ and self.gds_collector_ is not None:
            if not isinstance(value, str):
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' % {"value": value, "lineno": lineno, })
                return False
            value = value
            enumerations = ['EMAIL', 'TELEFAX', 'TELEPHONE', 'TELEX', 'URL', '']
            if value not in enumerations:
                lineno = self.gds_get_node_lineno_()
                self.gds_collector_.add_message('Value "%(value)s"%(lineno)s does not match xsd enumeration restriction on com.cisag.app.general.CommMedia' % {"value" : encode_str_2_3(value), "lineno": lineno} )
                result = False
        return result
    def has__content(self):
        if (
            self.name is not None or
            self.description is not None or
            self.media is not None
        ):
            return True
        else:
            return False
    def export(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='MethodType', pretty_print=True):
        imported_ns_def_ = GenerateDSNamespaceDefs_.get('MethodType')
        if imported_ns_def_ is not None:
            namespacedef_ = imported_ns_def_
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.original_tagname_ is not None and name_ == 'MethodType':
            name_ = self.original_tagname_
        if UseCapturedNS_ and self.ns_prefix_:
            namespaceprefix_ = self.ns_prefix_ + ':'
        showIndent(outfile, level, pretty_print)
        outfile.write('<%s%s%s' % (namespaceprefix_, name_, namespacedef_ and ' ' + namespacedef_ or '', ))
        already_processed = set()
        self._exportAttributes(outfile, level, already_processed, namespaceprefix_, name_='MethodType')
        if self.has__content():
            outfile.write('>%s' % (eol_, ))
            self._exportChildren(outfile, level + 1, namespaceprefix_, namespacedef_, name_='MethodType', pretty_print=pretty_print)
            showIndent(outfile, level, pretty_print)
            outfile.write('</%s%s>%s' % (namespaceprefix_, name_, eol_))
        else:
            outfile.write('/>%s' % (eol_, ))
    def _exportAttributes(self, outfile, level, already_processed, namespaceprefix_='', name_='MethodType'):
        if self.mark is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            outfile.write(' mark=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mark), input_name='mark')), ))
        if self.mode is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            outfile.write(' mode=%s' % (self.gds_encode(self.gds_format_string(quote_attrib(self.mode), input_name='mode')), ))
        if self.invalid is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            outfile.write(' invalid="%s"' % self.gds_format_boolean(self.invalid, input_name='invalid'))
    def _exportChildren(self, outfile, level, namespaceprefix_='', namespacedef_=' xmlns:None="com.cisag.app.general.obj.Partner" ', name_='MethodType', fromsubclass_=False, pretty_print=True):
        if pretty_print:
            eol_ = '\n'
        else:
            eol_ = ''
        if self.name is not None:
            namespaceprefix_ = self.name_nsprefix_ + ':' if (UseCapturedNS_ and self.name_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sname>%s</%sname>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.name), input_name='name')), namespaceprefix_ , eol_))
        if self.description is not None:
            namespaceprefix_ = self.description_nsprefix_ + ':' if (UseCapturedNS_ and self.description_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%sdescription>%s</%sdescription>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.description), input_name='description')), namespaceprefix_ , eol_))
        if self.media is not None:
            namespaceprefix_ = self.media_nsprefix_ + ':' if (UseCapturedNS_ and self.media_nsprefix_) else ''
            showIndent(outfile, level, pretty_print)
            outfile.write('<%smedia>%s</%smedia>%s' % (namespaceprefix_ , self.gds_encode(self.gds_format_string(quote_xml(self.media), input_name='media')), namespaceprefix_ , eol_))
    def build(self, node, gds_collector_=None):
        self.gds_collector_ = gds_collector_
        if SaveElementTreeNode:
            self.gds_elementtree_node_ = node
        already_processed = set()
        self.ns_prefix_ = node.prefix
        self._buildAttributes(node, node.attrib, already_processed)
        for child in node:
            nodeName_ = Tag_pattern_.match(child.tag).groups()[-1]
            self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_)
        return self
    def _buildAttributes(self, node, attrs, already_processed):
        value = find_attr_value_('mark', node)
        if value is not None and 'mark' not in already_processed:
            already_processed.add('mark')
            self.mark = value
        value = find_attr_value_('mode', node)
        if value is not None and 'mode' not in already_processed:
            already_processed.add('mode')
            self.mode = value
        value = find_attr_value_('invalid', node)
        if value is not None and 'invalid' not in already_processed:
            already_processed.add('invalid')
            if value in ('true', '1'):
                self.invalid = True
            elif value in ('false', '0'):
                self.invalid = False
            else:
                raise_parse_error(node, 'Bad boolean attribute')
    def _buildChildren(self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None):
        if nodeName_ == 'name':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'name')
            value_ = self.gds_validate_string(value_, node, 'name')
            self.name = value_
            self.name_nsprefix_ = child_.prefix
        elif nodeName_ == 'description':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'description')
            value_ = self.gds_validate_string(value_, node, 'description')
            self.description = value_
            self.description_nsprefix_ = child_.prefix
        elif nodeName_ == 'media':
            value_ = child_.text
            value_ = self.gds_parse_string(value_, node, 'media')
            value_ = self.gds_validate_string(value_, node, 'media')
            self.media = value_
            self.media_nsprefix_ = child_.prefix
            # validate type com.cisag.app.general.CommMedia
            self.validate_com_cisag_app_general_CommMedia(self.media)
# end class MethodType


#
# End data representation classes.
#


GDSClassesMapping = {
}


USAGE_TEXT = """
Usage: python <Parser>.py [ -s ] <in_xml_file>
"""


def usage():
    print(USAGE_TEXT)
    sys.exit(1)


def get_root_tag(node):
    tag = Tag_pattern_.match(node.tag).groups()[-1]
    prefix_tag = TagNamePrefix + tag
    rootClass = GDSClassesMapping.get(prefix_tag)
    if rootClass is None:
        rootClass = globals().get(prefix_tag)
    return tag, rootClass


def get_required_ns_prefix_defs(rootNode):
    '''Get all name space prefix definitions required in this XML doc.
    Return a dictionary of definitions and a char string of definitions.
    '''
    nsmap = {
        prefix: uri
        for node in rootNode.iter()
        for (prefix, uri) in node.nsmap.items()
        if prefix is not None
    }
    namespacedefs = ' '.join([
        'xmlns:{}="{}"'.format(prefix, uri)
        for prefix, uri in nsmap.items()
    ])
    return nsmap, namespacedefs


def parse(inFileName, silence=False, print_warnings=True):
    global CapturedNsmap_
    gds_collector = GdsCollector_()
    parser = None
    doc = parsexml_(inFileName, parser)
    rootNode = doc.getroot()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'semiramis'
        rootClass = semiramis
    rootObj = rootClass.factory()
    rootObj.build(rootNode, gds_collector_=gds_collector)
    CapturedNsmap_, namespacedefs = get_required_ns_prefix_defs(rootNode)
    if not SaveElementTreeNode:
        doc = None
        rootNode = None
    if not silence:
        sys.stdout.write('<?xml version="1.0" ?>\n')
        rootObj.export(
            sys.stdout, 0, name_=rootTag,
            namespacedef_=namespacedefs,
            pretty_print=True)
    if print_warnings and len(gds_collector.get_messages()) > 0:
        separator = ('-' * 50) + '\n'
        sys.stderr.write(separator)
        sys.stderr.write('----- Warnings -- count: {} -----\n'.format(
            len(gds_collector.get_messages()), ))
        gds_collector.write_messages(sys.stderr)
        sys.stderr.write(separator)
    return rootObj


def parseEtree(inFileName, silence=False, print_warnings=True,
               mapping=None, reverse_mapping=None, nsmap=None):
    parser = None
    doc = parsexml_(inFileName, parser)
    gds_collector = GdsCollector_()
    rootNode = doc.getroot()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'semiramis'
        rootClass = semiramis
    rootObj = rootClass.factory()
    rootObj.build(rootNode, gds_collector_=gds_collector)
    if mapping is None:
        mapping = {}
    if reverse_mapping is None:
        reverse_mapping = {}
    rootElement = rootObj.to_etree(
        None, name_=rootTag, mapping_=mapping,
        reverse_mapping_=reverse_mapping, nsmap_=nsmap)
    reverse_node_mapping = rootObj.gds_reverse_node_mapping(mapping)
    # Enable Python to collect the space used by the DOM.
    if not SaveElementTreeNode:
        doc = None
        rootNode = None
    if not silence:
        content = etree_.tostring(
            rootElement, pretty_print=True,
            xml_declaration=True, encoding="utf-8")
        sys.stdout.write(str(content))
        sys.stdout.write('\n')
    if print_warnings and len(gds_collector.get_messages()) > 0:
        separator = ('-' * 50) + '\n'
        sys.stderr.write(separator)
        sys.stderr.write('----- Warnings -- count: {} -----\n'.format(
            len(gds_collector.get_messages()), ))
        gds_collector.write_messages(sys.stderr)
        sys.stderr.write(separator)
    return rootObj, rootElement, mapping, reverse_node_mapping


def parseString(inString, silence=False, print_warnings=True):
    '''Parse a string, create the object tree, and export it.

    Arguments:
    - inString -- A string.  This XML fragment should not start
      with an XML declaration containing an encoding.
    - silence -- A boolean.  If False, export the object.
    Returns -- The root object in the tree.
    '''
    parser = None
    rootNode= parsexmlstring_(inString, parser)
    gds_collector = GdsCollector_()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'semiramis'
        rootClass = semiramis
    rootObj = rootClass.factory()
    rootObj.build(rootNode, gds_collector_=gds_collector)
    if not SaveElementTreeNode:
        rootNode = None
    if not silence:
        sys.stdout.write('<?xml version="1.0" ?>\n')
        rootObj.export(
            sys.stdout, 0, name_=rootTag,
            namespacedef_='')
    if print_warnings and len(gds_collector.get_messages()) > 0:
        separator = ('-' * 50) + '\n'
        sys.stderr.write(separator)
        sys.stderr.write('----- Warnings -- count: {} -----\n'.format(
            len(gds_collector.get_messages()), ))
        gds_collector.write_messages(sys.stderr)
        sys.stderr.write(separator)
    return rootObj


def parseLiteral(inFileName, silence=False, print_warnings=True):
    parser = None
    doc = parsexml_(inFileName, parser)
    gds_collector = GdsCollector_()
    rootNode = doc.getroot()
    rootTag, rootClass = get_root_tag(rootNode)
    if rootClass is None:
        rootTag = 'semiramis'
        rootClass = semiramis
    rootObj = rootClass.factory()
    rootObj.build(rootNode, gds_collector_=gds_collector)
    # Enable Python to collect the space used by the DOM.
    if not SaveElementTreeNode:
        doc = None
        rootNode = None
    if not silence:
        sys.stdout.write('#from partner_lib import *\n\n')
        sys.stdout.write('import partner_lib as model_\n\n')
        sys.stdout.write('rootObj = model_.rootClass(\n')
        rootObj.exportLiteral(sys.stdout, 0, name_=rootTag)
        sys.stdout.write(')\n')
    if print_warnings and len(gds_collector.get_messages()) > 0:
        separator = ('-' * 50) + '\n'
        sys.stderr.write(separator)
        sys.stderr.write('----- Warnings -- count: {} -----\n'.format(
            len(gds_collector.get_messages()), ))
        gds_collector.write_messages(sys.stderr)
        sys.stderr.write(separator)
    return rootObj


def main():
    args = sys.argv[1:]
    if len(args) == 1:
        parse(args[0])
    else:
        usage()


if __name__ == '__main__':
    #import pdb; pdb.set_trace()
    main()

RenameMappings_ = {
}

#
# Mapping of namespaces to types defined in them
# and the file in which each is defined.
# simpleTypes are marked "ST" and complexTypes "CT".
NamespaceToDefMappings_ = {'com.cisag.app.general.obj.Partner': [('com.cisag.app.general.CommMedia',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('com.cisag.app.general.Gender',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('com.cisag.app.general.PartnerCustomerStatus',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('java.lang.Byte',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('java.lang.Short',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('java.lang.Integer',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('java.lang.Long',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST'),
                                       ('java.lang.Character',
                                        'definitions/PARTNER_SHOP_.xsd',
                                        'ST')]}

__all__ = [
    "CommunicationDataType",
    "CountryType",
    "CustomerType",
    "Imp_CustomerPossibleOrderTypesType",
    "Imp_CustomerPossibleSalesItemType",
    "Imp_SizeSurchargeListingType",
    "ItemType",
    "MethodType",
    "PartnerAccountingDataType",
    "PartnerType",
    "PriceListingType",
    "PriceListingType1",
    "SalesPaymentTermsType",
    "SalutationType",
    "ShippingTermsType",
    "TitleType",
    "addressDataType",
    "deliveryDataInfoType",
    "eansType",
    "organizationalUnitType",
    "personType",
    "semiramis"
]